Added staleness test to keep ruby-upb.{c,h} amalgamation files in sync with upb repo (#10496)
* Added staleness test for ruby-upb.{c,h} and updated.
* Removed file comment markers, too much trouble for too little benefit.
* Ran clang-format.
* Updated ruby-upb.{c,h}.
* Added missing table code to amalgamation.
* Updated to latest upb, patch no longer needed.
* Reverted changes to third_party sub-modules.
* Added missing unicode file.
* Removed conformance failures for Ruby.diff --git a/ruby/BUILD.bazel b/ruby/BUILD.bazel
index d014402..5e15d92 100644
--- a/ruby/BUILD.bazel
+++ b/ruby/BUILD.bazel
@@ -3,6 +3,7 @@
# See also code generation logic under /src/google/protobuf/compiler/ruby.
load("@rules_pkg//:mappings.bzl", "pkg_files", "strip_prefix")
+load("@upb//cmake:build_defs.bzl", "staleness_test")
load("//build_defs:internal_shell.bzl", "inline_sh_test")
load("//conformance:defs.bzl", "conformance_test")
load("//:protobuf.bzl", "internal_ruby_proto_library")
@@ -161,6 +162,29 @@
}),
)
+genrule(
+ name = "copy_ruby_amalgamation_h",
+ srcs = ["@upb//:ruby-upb.h"],
+ outs = ["generated-in/ext/google/protobuf_c/ruby-upb.h"],
+ cmd = "cp $< $@",
+)
+
+genrule(
+ name = "copy_ruby_amalgamation_c",
+ srcs = ["@upb//:ruby-upb.c"],
+ outs = ["generated-in/ext/google/protobuf_c/ruby-upb.c"],
+ cmd = "cp $< $@",
+)
+
+staleness_test(
+ name = "test_amalgamation_staleness",
+ outs = [
+ "ext/google/protobuf_c/ruby-upb.h",
+ "ext/google/protobuf_c/ruby-upb.c",
+ ],
+ generated_pattern = "generated-in/%s",
+)
+
################################################################################
# Distribution files
################################################################################
diff --git a/ruby/ext/google/protobuf_c/message.c b/ruby/ext/google/protobuf_c/message.c
index 5acff80..6295136 100644
--- a/ruby/ext/google/protobuf_c/message.c
+++ b/ruby/ext/google/protobuf_c/message.c
@@ -696,15 +696,20 @@
if (m1 == m2) return true;
size_t size1, size2;
- int encode_opts = kUpb_Encode_SkipUnknown | kUpb_Encode_Deterministic;
+ int encode_opts =
+ kUpb_EncodeOption_SkipUnknown | kUpb_EncodeOption_Deterministic;
upb_Arena* arena_tmp = upb_Arena_New();
const upb_MiniTable* layout = upb_MessageDef_MiniTable(m);
// Compare deterministically serialized payloads with no unknown fields.
- char* data1 = upb_Encode(m1, layout, encode_opts, arena_tmp, &size1);
- char* data2 = upb_Encode(m2, layout, encode_opts, arena_tmp, &size2);
+ char* data1;
+ char* data2;
+ upb_EncodeStatus status1 =
+ upb_Encode(m1, layout, encode_opts, arena_tmp, &data1, &size1);
+ upb_EncodeStatus status2 =
+ upb_Encode(m2, layout, encode_opts, arena_tmp, &data2, &size2);
- if (data1 && data2) {
+ if (status1 == kUpb_EncodeStatus_Ok && status2 == kUpb_EncodeStatus_Ok) {
bool ret = (size1 == size2) && (memcmp(data1, data2, size1) == 0);
upb_Arena_Free(arena_tmp);
return ret;
@@ -736,15 +741,16 @@
uint64_t Message_Hash(const upb_Message* msg, const upb_MessageDef* m,
uint64_t seed) {
upb_Arena* arena = upb_Arena_New();
- const char* data;
+ char* data;
size_t size;
// Hash a deterministically serialized payloads with no unknown fields.
- data = upb_Encode(msg, upb_MessageDef_MiniTable(m),
- kUpb_Encode_SkipUnknown | kUpb_Encode_Deterministic, arena,
- &size);
+ upb_EncodeStatus status = upb_Encode(
+ msg, upb_MessageDef_MiniTable(m),
+ kUpb_EncodeOption_SkipUnknown | kUpb_EncodeOption_Deterministic, arena,
+ &data, &size);
- if (data) {
+ if (status == kUpb_EncodeStatus_Ok) {
uint64_t ret = _upb_Hash(data, size, seed);
upb_Arena_Free(arena);
return ret;
@@ -970,7 +976,8 @@
rb_raise(rb_eArgError, "Expected hash arguments.");
}
- VALUE depth = rb_hash_lookup(hash_args, ID2SYM(rb_intern("recursion_limit")));
+ VALUE depth =
+ rb_hash_lookup(hash_args, ID2SYM(rb_intern("recursion_limit")));
if (depth != Qnil && TYPE(depth) == T_FIXNUM) {
options |= UPB_DECODE_MAXDEPTH(FIX2INT(depth));
@@ -984,9 +991,10 @@
VALUE msg_rb = initialize_rb_class_with_no_args(klass);
Message* msg = ruby_to_Message(msg_rb);
- upb_DecodeStatus status = upb_Decode(
- RSTRING_PTR(data), RSTRING_LEN(data), (upb_Message*)msg->msg,
- upb_MessageDef_MiniTable(msg->msgdef), NULL, options, Arena_get(msg->arena));
+ upb_DecodeStatus status =
+ upb_Decode(RSTRING_PTR(data), RSTRING_LEN(data), (upb_Message*)msg->msg,
+ upb_MessageDef_MiniTable(msg->msgdef), NULL, options,
+ Arena_get(msg->arena));
if (status != kUpb_DecodeStatus_Ok) {
rb_raise(cParseError, "Error occurred during parsing");
@@ -1070,7 +1078,7 @@
static VALUE Message_encode(int argc, VALUE* argv, VALUE klass) {
Message* msg = ruby_to_Message(argv[0]);
int options = 0;
- const char* data;
+ char* data;
size_t size;
if (CLASS_OF(argv[0]) != klass) {
@@ -1086,19 +1094,21 @@
if (TYPE(hash_args) != T_HASH) {
rb_raise(rb_eArgError, "Expected hash arguments.");
}
- VALUE depth = rb_hash_lookup(hash_args, ID2SYM(rb_intern("recursion_limit")));
+ VALUE depth =
+ rb_hash_lookup(hash_args, ID2SYM(rb_intern("recursion_limit")));
if (depth != Qnil && TYPE(depth) == T_FIXNUM) {
options |= UPB_DECODE_MAXDEPTH(FIX2INT(depth));
}
}
- upb_Arena *arena = upb_Arena_New();
+ upb_Arena* arena = upb_Arena_New();
- data = upb_Encode(msg->msg, upb_MessageDef_MiniTable(msg->msgdef),
- options, arena, &size);
+ upb_EncodeStatus status =
+ upb_Encode(msg->msg, upb_MessageDef_MiniTable(msg->msgdef), options,
+ arena, &data, &size);
- if (data) {
+ if (status == kUpb_EncodeStatus_Ok) {
VALUE ret = rb_str_new(data, size);
rb_enc_associate(ret, rb_ascii8bit_encoding());
upb_Arena_Free(arena);
@@ -1136,7 +1146,8 @@
if (argc == 2) {
VALUE hash_args = argv[1];
if (TYPE(hash_args) != T_HASH) {
- if (RTEST(rb_funcall(hash_args, rb_intern("respond_to?"), 1, rb_str_new2("to_h")))) {
+ if (RTEST(rb_funcall(hash_args, rb_intern("respond_to?"), 1,
+ rb_str_new2("to_h")))) {
hash_args = rb_funcall(hash_args, rb_intern("to_h"), 0);
} else {
rb_raise(rb_eArgError, "Expected hash arguments.");
@@ -1295,11 +1306,13 @@
const upb_MiniTable* layout = upb_MessageDef_MiniTable(m);
size_t size;
- char* data = upb_Encode(msg, layout, 0, tmp_arena, &size);
upb_Message* new_msg = upb_Message_New(m, arena);
+ char* data;
- if (!data || upb_Decode(data, size, new_msg, layout, NULL, 0, arena) !=
- kUpb_DecodeStatus_Ok) {
+ if (upb_Encode(msg, layout, 0, tmp_arena, &data, &size) !=
+ kUpb_EncodeStatus_Ok ||
+ upb_Decode(data, size, new_msg, layout, NULL, 0, arena) !=
+ kUpb_DecodeStatus_Ok) {
upb_Arena_Free(tmp_arena);
rb_raise(cParseError, "Error occurred copying proto");
}
@@ -1399,7 +1412,8 @@
void Message_register(VALUE protobuf) {
cParseError = rb_const_get(protobuf, rb_intern("ParseError"));
- cAbstractMessage = rb_define_class_under(protobuf, "AbstractMessage", rb_cObject);
+ cAbstractMessage =
+ rb_define_class_under(protobuf, "AbstractMessage", rb_cObject);
Message_define_class(cAbstractMessage);
rb_gc_register_address(&cAbstractMessage);
diff --git a/ruby/ext/google/protobuf_c/ruby-upb.c b/ruby/ext/google/protobuf_c/ruby-upb.c
old mode 100755
new mode 100644
index d50bd99..22d2393
--- a/ruby/ext/google/protobuf_c/ruby-upb.c
+++ b/ruby/ext/google/protobuf_c/ruby-upb.c
@@ -1,31 +1,5 @@
/* Amalgamated source file */
#include "ruby-upb.h"
-/*
- * Copyright (c) 2009-2021, Google LLC
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of Google LLC nor the
- * names of its contributors may be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
/*
* This is where we define macros used across upb.
@@ -56,8 +30,20 @@
#error upb requires C99 or C++11 or MSVC >= 2015.
#endif
-#include <stdint.h>
+// Portable check for GCC minimum version:
+// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
+#define UPB_GNUC_MIN(x, y) \
+ (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
+#else
+#define UPB_GNUC_MIN(x, y) 0
+#endif
+
+#include <assert.h>
+#include <setjmp.h>
+#include <stdbool.h>
#include <stddef.h>
+#include <stdint.h>
#if UINTPTR_MAX == 0xffffffff
#define UPB_SIZE(size32, size64) size32
@@ -90,9 +76,10 @@
#define UPB_INLINE static
#endif
+#define UPB_MALLOC_ALIGN 8
#define UPB_ALIGN_UP(size, align) (((size) + (align) - 1) / (align) * (align))
#define UPB_ALIGN_DOWN(size, align) ((size) / (align) * (align))
-#define UPB_ALIGN_MALLOC(size) UPB_ALIGN_UP(size, 16)
+#define UPB_ALIGN_MALLOC(size) UPB_ALIGN_UP(size, UPB_MALLOC_ALIGN)
#define UPB_ALIGN_OF(type) offsetof (struct { char c; type member; }, member)
/* Hints to the compiler about likely/unlikely branches. */
@@ -230,7 +217,11 @@
#undef UPB_FASTTABLE_SUPPORTED
-/* ASAN poisoning (for arena) *************************************************/
+/* ASAN poisoning (for arena).
+ * If using UPB from an interpreted language like Ruby, a build of the
+ * interpreter compiled with ASAN enbabled must be used in order to get sane and
+ * expected behavior.
+ */
#if defined(__SANITIZE_ADDRESS__)
#define UPB_ASAN 1
@@ -262,1835 +253,37 @@
#define UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3 0
#endif
-/** upb/decode.c ************************************************************/
+#if defined(__cplusplus)
+#if defined(__clang__) || UPB_GNUC_MIN(6, 0)
+// https://gcc.gnu.org/gcc-6/changes.html
+#if __cplusplus >= 201402L
+#define UPB_DEPRECATED [[deprecated]]
+#else
+#define UPB_DEPRECATED __attribute__((deprecated))
+#endif
+#else
+#define UPB_DEPRECATED
+#endif
+#else
+#define UPB_DEPRECATED
+#endif
-#include <setjmp.h>
+
#include <string.h>
+// Must be last.
-/* Must be last. */
-
-/* Maps descriptor type -> elem_size_lg2. */
-static const uint8_t desctype_to_elem_size_lg2[] = {
- -1, /* invalid descriptor type */
- 3, /* DOUBLE */
- 2, /* FLOAT */
- 3, /* INT64 */
- 3, /* UINT64 */
- 2, /* INT32 */
- 3, /* FIXED64 */
- 2, /* FIXED32 */
- 0, /* BOOL */
- UPB_SIZE(3, 4), /* STRING */
- UPB_SIZE(2, 3), /* GROUP */
- UPB_SIZE(2, 3), /* MESSAGE */
- UPB_SIZE(3, 4), /* BYTES */
- 2, /* UINT32 */
- 2, /* ENUM */
- 2, /* SFIXED32 */
- 3, /* SFIXED64 */
- 2, /* SINT32 */
- 3, /* SINT64 */
-};
-
-/* Maps descriptor type -> upb map size. */
-static const uint8_t desctype_to_mapsize[] = {
- -1, /* invalid descriptor type */
- 8, /* DOUBLE */
- 4, /* FLOAT */
- 8, /* INT64 */
- 8, /* UINT64 */
- 4, /* INT32 */
- 8, /* FIXED64 */
- 4, /* FIXED32 */
- 1, /* BOOL */
- UPB_MAPTYPE_STRING, /* STRING */
- sizeof(void*), /* GROUP */
- sizeof(void*), /* MESSAGE */
- UPB_MAPTYPE_STRING, /* BYTES */
- 4, /* UINT32 */
- 4, /* ENUM */
- 4, /* SFIXED32 */
- 8, /* SFIXED64 */
- 4, /* SINT32 */
- 8, /* SINT64 */
-};
-
-static const unsigned FIXED32_OK_MASK = (1 << kUpb_FieldType_Float) |
- (1 << kUpb_FieldType_Fixed32) |
- (1 << kUpb_FieldType_SFixed32);
-
-static const unsigned FIXED64_OK_MASK = (1 << kUpb_FieldType_Double) |
- (1 << kUpb_FieldType_Fixed64) |
- (1 << kUpb_FieldType_SFixed64);
-
-/* Three fake field types for MessageSet. */
-#define TYPE_MSGSET_ITEM 19
-#define TYPE_MSGSET_TYPE_ID 20
-#define TYPE_COUNT 20
-
-/* Op: an action to be performed for a wire-type/field-type combination. */
-#define OP_UNKNOWN -1 /* Unknown field. */
-#define OP_MSGSET_ITEM -2
-#define OP_MSGSET_TYPEID -3
-#define OP_SCALAR_LG2(n) (n) /* n in [0, 2, 3] => op in [0, 2, 3] */
-#define OP_ENUM 1
-#define OP_STRING 4
-#define OP_BYTES 5
-#define OP_SUBMSG 6
-/* Scalar fields use only ops above. Repeated fields can use any op. */
-#define OP_FIXPCK_LG2(n) (n + 5) /* n in [2, 3] => op in [7, 8] */
-#define OP_VARPCK_LG2(n) (n + 9) /* n in [0, 2, 3] => op in [9, 11, 12] */
-#define OP_PACKED_ENUM 13
-
-static const int8_t varint_ops[] = {
- OP_UNKNOWN, /* field not found */
- OP_UNKNOWN, /* DOUBLE */
- OP_UNKNOWN, /* FLOAT */
- OP_SCALAR_LG2(3), /* INT64 */
- OP_SCALAR_LG2(3), /* UINT64 */
- OP_SCALAR_LG2(2), /* INT32 */
- OP_UNKNOWN, /* FIXED64 */
- OP_UNKNOWN, /* FIXED32 */
- OP_SCALAR_LG2(0), /* BOOL */
- OP_UNKNOWN, /* STRING */
- OP_UNKNOWN, /* GROUP */
- OP_UNKNOWN, /* MESSAGE */
- OP_UNKNOWN, /* BYTES */
- OP_SCALAR_LG2(2), /* UINT32 */
- OP_ENUM, /* ENUM */
- OP_UNKNOWN, /* SFIXED32 */
- OP_UNKNOWN, /* SFIXED64 */
- OP_SCALAR_LG2(2), /* SINT32 */
- OP_SCALAR_LG2(3), /* SINT64 */
- OP_UNKNOWN, /* MSGSET_ITEM */
- OP_MSGSET_TYPEID, /* MSGSET TYPEID */
-};
-
-static const int8_t delim_ops[] = {
- /* For non-repeated field type. */
- OP_UNKNOWN, /* field not found */
- OP_UNKNOWN, /* DOUBLE */
- OP_UNKNOWN, /* FLOAT */
- OP_UNKNOWN, /* INT64 */
- OP_UNKNOWN, /* UINT64 */
- OP_UNKNOWN, /* INT32 */
- OP_UNKNOWN, /* FIXED64 */
- OP_UNKNOWN, /* FIXED32 */
- OP_UNKNOWN, /* BOOL */
- OP_STRING, /* STRING */
- OP_UNKNOWN, /* GROUP */
- OP_SUBMSG, /* MESSAGE */
- OP_BYTES, /* BYTES */
- OP_UNKNOWN, /* UINT32 */
- OP_UNKNOWN, /* ENUM */
- OP_UNKNOWN, /* SFIXED32 */
- OP_UNKNOWN, /* SFIXED64 */
- OP_UNKNOWN, /* SINT32 */
- OP_UNKNOWN, /* SINT64 */
- OP_UNKNOWN, /* MSGSET_ITEM */
- OP_UNKNOWN, /* MSGSET TYPEID */
- /* For repeated field type. */
- OP_FIXPCK_LG2(3), /* REPEATED DOUBLE */
- OP_FIXPCK_LG2(2), /* REPEATED FLOAT */
- OP_VARPCK_LG2(3), /* REPEATED INT64 */
- OP_VARPCK_LG2(3), /* REPEATED UINT64 */
- OP_VARPCK_LG2(2), /* REPEATED INT32 */
- OP_FIXPCK_LG2(3), /* REPEATED FIXED64 */
- OP_FIXPCK_LG2(2), /* REPEATED FIXED32 */
- OP_VARPCK_LG2(0), /* REPEATED BOOL */
- OP_STRING, /* REPEATED STRING */
- OP_SUBMSG, /* REPEATED GROUP */
- OP_SUBMSG, /* REPEATED MESSAGE */
- OP_BYTES, /* REPEATED BYTES */
- OP_VARPCK_LG2(2), /* REPEATED UINT32 */
- OP_PACKED_ENUM, /* REPEATED ENUM */
- OP_FIXPCK_LG2(2), /* REPEATED SFIXED32 */
- OP_FIXPCK_LG2(3), /* REPEATED SFIXED64 */
- OP_VARPCK_LG2(2), /* REPEATED SINT32 */
- OP_VARPCK_LG2(3), /* REPEATED SINT64 */
- /* Omitting MSGSET_*, because we never emit a repeated msgset type */
-};
-
-typedef union {
- bool bool_val;
- uint32_t uint32_val;
- uint64_t uint64_val;
- uint32_t size;
-} wireval;
-
-static const char* decode_msg(upb_Decoder* d, const char* ptr, upb_Message* msg,
- const upb_MiniTable* layout);
-
-UPB_NORETURN static void* decode_err(upb_Decoder* d, upb_DecodeStatus status) {
- assert(status != kUpb_DecodeStatus_Ok);
- UPB_LONGJMP(d->err, status);
-}
-
-const char* fastdecode_err(upb_Decoder* d, int status) {
- assert(status != kUpb_DecodeStatus_Ok);
- UPB_LONGJMP(d->err, status);
- return NULL;
-}
-static void decode_verifyutf8(upb_Decoder* d, const char* buf, int len) {
- if (!decode_verifyutf8_inl(buf, len))
- decode_err(d, kUpb_DecodeStatus_BadUtf8);
-}
-
-static bool decode_reserve(upb_Decoder* d, upb_Array* arr, size_t elem) {
- bool need_realloc = arr->size - arr->len < elem;
- if (need_realloc && !_upb_array_realloc(arr, arr->len + elem, &d->arena)) {
- decode_err(d, kUpb_DecodeStatus_OutOfMemory);
- }
- return need_realloc;
-}
-
-typedef struct {
- const char* ptr;
- uint64_t val;
-} decode_vret;
-
-UPB_NOINLINE
-static decode_vret decode_longvarint64(const char* ptr, uint64_t val) {
- decode_vret ret = {NULL, 0};
- uint64_t byte;
- int i;
- for (i = 1; i < 10; i++) {
- byte = (uint8_t)ptr[i];
- val += (byte - 1) << (i * 7);
- if (!(byte & 0x80)) {
- ret.ptr = ptr + i + 1;
- ret.val = val;
- return ret;
- }
- }
- return ret;
-}
-
-UPB_FORCEINLINE
-static const char* decode_varint64(upb_Decoder* d, const char* ptr,
- uint64_t* val) {
- uint64_t byte = (uint8_t)*ptr;
- if (UPB_LIKELY((byte & 0x80) == 0)) {
- *val = byte;
- return ptr + 1;
- } else {
- decode_vret res = decode_longvarint64(ptr, byte);
- if (!res.ptr) return decode_err(d, kUpb_DecodeStatus_Malformed);
- *val = res.val;
- return res.ptr;
- }
-}
-
-UPB_FORCEINLINE
-static const char* decode_tag(upb_Decoder* d, const char* ptr, uint32_t* val) {
- uint64_t byte = (uint8_t)*ptr;
- if (UPB_LIKELY((byte & 0x80) == 0)) {
- *val = byte;
- return ptr + 1;
- } else {
- const char* start = ptr;
- decode_vret res = decode_longvarint64(ptr, byte);
- if (!res.ptr || res.ptr - start > 5 || res.val > UINT32_MAX) {
- return decode_err(d, kUpb_DecodeStatus_Malformed);
- }
- *val = res.val;
- return res.ptr;
- }
-}
-
-static void decode_munge_int32(wireval* val) {
- if (!_upb_IsLittleEndian()) {
- /* The next stage will memcpy(dst, &val, 4) */
- val->uint32_val = val->uint64_val;
- }
-}
-
-static void decode_munge(int type, wireval* val) {
- switch (type) {
- case kUpb_FieldType_Bool:
- val->bool_val = val->uint64_val != 0;
- break;
- case kUpb_FieldType_SInt32: {
- uint32_t n = val->uint64_val;
- val->uint32_val = (n >> 1) ^ -(int32_t)(n & 1);
- break;
- }
- case kUpb_FieldType_SInt64: {
- uint64_t n = val->uint64_val;
- val->uint64_val = (n >> 1) ^ -(int64_t)(n & 1);
- break;
- }
- case kUpb_FieldType_Int32:
- case kUpb_FieldType_UInt32:
- case kUpb_FieldType_Enum:
- decode_munge_int32(val);
- break;
- }
-}
-
-static upb_Message* decode_newsubmsg(upb_Decoder* d,
- const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* field) {
- const upb_MiniTable* subl = subs[field->submsg_index].submsg;
- return _upb_Message_New_inl(subl, &d->arena);
-}
-
-UPB_NOINLINE
-const char* decode_isdonefallback(upb_Decoder* d, const char* ptr,
- int overrun) {
- int status;
- ptr = decode_isdonefallback_inl(d, ptr, overrun, &status);
- if (ptr == NULL) {
- return decode_err(d, status);
- }
- return ptr;
-}
-
-static const char* decode_readstr(upb_Decoder* d, const char* ptr, int size,
- upb_StringView* str) {
- if (d->options & kUpb_DecodeOption_AliasString) {
- str->data = ptr;
- } else {
- char* data = upb_Arena_Malloc(&d->arena, size);
- if (!data) return decode_err(d, kUpb_DecodeStatus_OutOfMemory);
- memcpy(data, ptr, size);
- str->data = data;
- }
- str->size = size;
- return ptr + size;
-}
-
-UPB_FORCEINLINE
-static const char* decode_tosubmsg2(upb_Decoder* d, const char* ptr,
- upb_Message* submsg,
- const upb_MiniTable* subl, int size) {
- int saved_delta = decode_pushlimit(d, ptr, size);
- if (--d->depth < 0) return decode_err(d, kUpb_DecodeStatus_MaxDepthExceeded);
- ptr = decode_msg(d, ptr, submsg, subl);
- if (d->end_group != DECODE_NOGROUP)
- return decode_err(d, kUpb_DecodeStatus_Malformed);
- decode_poplimit(d, ptr, saved_delta);
- d->depth++;
- return ptr;
-}
-
-UPB_FORCEINLINE
-static const char* decode_tosubmsg(upb_Decoder* d, const char* ptr,
- upb_Message* submsg,
- const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* field, int size) {
- return decode_tosubmsg2(d, ptr, submsg, subs[field->submsg_index].submsg,
- size);
-}
-
-UPB_FORCEINLINE
-static const char* decode_group(upb_Decoder* d, const char* ptr,
- upb_Message* submsg, const upb_MiniTable* subl,
- uint32_t number) {
- if (--d->depth < 0) return decode_err(d, kUpb_DecodeStatus_MaxDepthExceeded);
- if (decode_isdone(d, &ptr)) {
- return decode_err(d, kUpb_DecodeStatus_Malformed);
- }
- ptr = decode_msg(d, ptr, submsg, subl);
- if (d->end_group != number) return decode_err(d, kUpb_DecodeStatus_Malformed);
- d->end_group = DECODE_NOGROUP;
- d->depth++;
- return ptr;
-}
-
-UPB_FORCEINLINE
-static const char* decode_togroup(upb_Decoder* d, const char* ptr,
- upb_Message* submsg,
- const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* field) {
- const upb_MiniTable* subl = subs[field->submsg_index].submsg;
- return decode_group(d, ptr, submsg, subl, field->number);
-}
-
-static char* encode_varint32(uint32_t val, char* ptr) {
- do {
- uint8_t byte = val & 0x7fU;
- val >>= 7;
- if (val) byte |= 0x80U;
- *(ptr++) = byte;
- } while (val);
- return ptr;
-}
-
-static void upb_Decode_AddUnknownVarints(upb_Decoder* d, upb_Message* msg,
- uint32_t val1, uint32_t val2) {
- char buf[20];
- char* end = buf;
- end = encode_varint32(val1, end);
- end = encode_varint32(val2, end);
-
- if (!_upb_Message_AddUnknown(msg, buf, end - buf, &d->arena)) {
- decode_err(d, kUpb_DecodeStatus_OutOfMemory);
- }
-}
-
-UPB_NOINLINE
-static bool decode_checkenum_slow(upb_Decoder* d, const char* ptr,
- upb_Message* msg, const upb_MiniTable_Enum* e,
- const upb_MiniTable_Field* field,
- uint32_t v) {
- // OPT: binary search long lists?
- int n = e->value_count;
- for (int i = 0; i < n; i++) {
- if ((uint32_t)e->values[i] == v) return true;
- }
-
- // Unrecognized enum goes into unknown fields.
- // For packed fields the tag could be arbitrarily far in the past, so we
- // just re-encode the tag and value here.
- uint32_t tag = ((uint32_t)field->number << 3) | kUpb_WireType_Varint;
- upb_Decode_AddUnknownVarints(d, msg, tag, v);
- return false;
-}
-
-UPB_FORCEINLINE
-static bool decode_checkenum(upb_Decoder* d, const char* ptr, upb_Message* msg,
- const upb_MiniTable_Enum* e,
- const upb_MiniTable_Field* field, wireval* val) {
- uint32_t v = val->uint32_val;
-
- if (UPB_LIKELY(v < 64) && UPB_LIKELY(((1ULL << v) & e->mask))) return true;
-
- return decode_checkenum_slow(d, ptr, msg, e, field, v);
-}
-
-UPB_NOINLINE
-static const char* decode_enum_toarray(upb_Decoder* d, const char* ptr,
- upb_Message* msg, upb_Array* arr,
- const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* field,
- wireval* val) {
- const upb_MiniTable_Enum* e = subs[field->submsg_index].subenum;
- if (!decode_checkenum(d, ptr, msg, e, field, val)) return ptr;
- void* mem = UPB_PTR_AT(_upb_array_ptr(arr), arr->len * 4, void);
- arr->len++;
- memcpy(mem, val, 4);
- return ptr;
-}
-
-UPB_FORCEINLINE
-static const char* decode_fixed_packed(upb_Decoder* d, const char* ptr,
- upb_Array* arr, wireval* val,
- const upb_MiniTable_Field* field,
- int lg2) {
- int mask = (1 << lg2) - 1;
- size_t count = val->size >> lg2;
- if ((val->size & mask) != 0) {
- // Length isn't a round multiple of elem size.
- return decode_err(d, kUpb_DecodeStatus_Malformed);
- }
- decode_reserve(d, arr, count);
- void* mem = UPB_PTR_AT(_upb_array_ptr(arr), arr->len << lg2, void);
- arr->len += count;
- // Note: if/when the decoder supports multi-buffer input, we will need to
- // handle buffer seams here.
- if (_upb_IsLittleEndian()) {
- memcpy(mem, ptr, val->size);
- ptr += val->size;
- } else {
- const char* end = ptr + val->size;
- char* dst = mem;
- while (ptr < end) {
- if (lg2 == 2) {
- uint32_t val;
- memcpy(&val, ptr, sizeof(val));
- val = _upb_BigEndian_Swap32(val);
- memcpy(dst, &val, sizeof(val));
- } else {
- UPB_ASSERT(lg2 == 3);
- uint64_t val;
- memcpy(&val, ptr, sizeof(val));
- val = _upb_BigEndian_Swap64(val);
- memcpy(dst, &val, sizeof(val));
- }
- ptr += 1 << lg2;
- dst += 1 << lg2;
- }
- }
-
- return ptr;
-}
-
-UPB_FORCEINLINE
-static const char* decode_varint_packed(upb_Decoder* d, const char* ptr,
- upb_Array* arr, wireval* val,
- const upb_MiniTable_Field* field,
- int lg2) {
- int scale = 1 << lg2;
- int saved_limit = decode_pushlimit(d, ptr, val->size);
- char* out = UPB_PTR_AT(_upb_array_ptr(arr), arr->len << lg2, void);
- while (!decode_isdone(d, &ptr)) {
- wireval elem;
- ptr = decode_varint64(d, ptr, &elem.uint64_val);
- decode_munge(field->descriptortype, &elem);
- if (decode_reserve(d, arr, 1)) {
- out = UPB_PTR_AT(_upb_array_ptr(arr), arr->len << lg2, void);
- }
- arr->len++;
- memcpy(out, &elem, scale);
- out += scale;
- }
- decode_poplimit(d, ptr, saved_limit);
- return ptr;
-}
-
-UPB_NOINLINE
-static const char* decode_enum_packed(upb_Decoder* d, const char* ptr,
- upb_Message* msg, upb_Array* arr,
- const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* field,
- wireval* val) {
- const upb_MiniTable_Enum* e = subs[field->submsg_index].subenum;
- int saved_limit = decode_pushlimit(d, ptr, val->size);
- char* out = UPB_PTR_AT(_upb_array_ptr(arr), arr->len * 4, void);
- while (!decode_isdone(d, &ptr)) {
- wireval elem;
- ptr = decode_varint64(d, ptr, &elem.uint64_val);
- decode_munge_int32(&elem);
- if (!decode_checkenum(d, ptr, msg, e, field, &elem)) {
- continue;
- }
- if (decode_reserve(d, arr, 1)) {
- out = UPB_PTR_AT(_upb_array_ptr(arr), arr->len * 4, void);
- }
- arr->len++;
- memcpy(out, &elem, 4);
- out += 4;
- }
- decode_poplimit(d, ptr, saved_limit);
- return ptr;
-}
-
-static const char* decode_toarray(upb_Decoder* d, const char* ptr,
- upb_Message* msg,
- const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* field,
- wireval* val, int op) {
- upb_Array** arrp = UPB_PTR_AT(msg, field->offset, void);
- upb_Array* arr = *arrp;
- void* mem;
-
- if (arr) {
- decode_reserve(d, arr, 1);
- } else {
- size_t lg2 = desctype_to_elem_size_lg2[field->descriptortype];
- arr = _upb_Array_New(&d->arena, 4, lg2);
- if (!arr) return decode_err(d, kUpb_DecodeStatus_OutOfMemory);
- *arrp = arr;
- }
-
- switch (op) {
- case OP_SCALAR_LG2(0):
- case OP_SCALAR_LG2(2):
- case OP_SCALAR_LG2(3):
- /* Append scalar value. */
- mem = UPB_PTR_AT(_upb_array_ptr(arr), arr->len << op, void);
- arr->len++;
- memcpy(mem, val, 1 << op);
- return ptr;
- case OP_STRING:
- decode_verifyutf8(d, ptr, val->size);
- /* Fallthrough. */
- case OP_BYTES: {
- /* Append bytes. */
- upb_StringView* str = (upb_StringView*)_upb_array_ptr(arr) + arr->len;
- arr->len++;
- return decode_readstr(d, ptr, val->size, str);
- }
- case OP_SUBMSG: {
- /* Append submessage / group. */
- upb_Message* submsg = decode_newsubmsg(d, subs, field);
- *UPB_PTR_AT(_upb_array_ptr(arr), arr->len * sizeof(void*), upb_Message*) =
- submsg;
- arr->len++;
- if (UPB_UNLIKELY(field->descriptortype == kUpb_FieldType_Group)) {
- return decode_togroup(d, ptr, submsg, subs, field);
- } else {
- return decode_tosubmsg(d, ptr, submsg, subs, field, val->size);
- }
- }
- case OP_FIXPCK_LG2(2):
- case OP_FIXPCK_LG2(3):
- return decode_fixed_packed(d, ptr, arr, val, field,
- op - OP_FIXPCK_LG2(0));
- case OP_VARPCK_LG2(0):
- case OP_VARPCK_LG2(2):
- case OP_VARPCK_LG2(3):
- return decode_varint_packed(d, ptr, arr, val, field,
- op - OP_VARPCK_LG2(0));
- case OP_ENUM:
- return decode_enum_toarray(d, ptr, msg, arr, subs, field, val);
- case OP_PACKED_ENUM:
- return decode_enum_packed(d, ptr, msg, arr, subs, field, val);
- default:
- UPB_UNREACHABLE();
- }
-}
-
-static const char* decode_tomap(upb_Decoder* d, const char* ptr,
- upb_Message* msg, const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* field,
- wireval* val) {
- upb_Map** map_p = UPB_PTR_AT(msg, field->offset, upb_Map*);
- upb_Map* map = *map_p;
- upb_MapEntry ent;
- const upb_MiniTable* entry = subs[field->submsg_index].submsg;
-
- if (!map) {
- /* Lazily create map. */
- const upb_MiniTable_Field* key_field = &entry->fields[0];
- const upb_MiniTable_Field* val_field = &entry->fields[1];
- char key_size = desctype_to_mapsize[key_field->descriptortype];
- char val_size = desctype_to_mapsize[val_field->descriptortype];
- UPB_ASSERT(key_field->offset == 0);
- UPB_ASSERT(val_field->offset == sizeof(upb_StringView));
- map = _upb_Map_New(&d->arena, key_size, val_size);
- *map_p = map;
- }
-
- /* Parse map entry. */
- memset(&ent, 0, sizeof(ent));
-
- if (entry->fields[1].descriptortype == kUpb_FieldType_Message ||
- entry->fields[1].descriptortype == kUpb_FieldType_Group) {
- /* Create proactively to handle the case where it doesn't appear. */
- ent.v.val =
- upb_value_ptr(_upb_Message_New(entry->subs[0].submsg, &d->arena));
- }
-
- const char* start = ptr;
- ptr = decode_tosubmsg(d, ptr, &ent.k, subs, field, val->size);
- // check if ent had any unknown fields
- size_t size;
- upb_Message_GetUnknown(&ent.k, &size);
- if (size != 0) {
- uint32_t tag = ((uint32_t)field->number << 3) | kUpb_WireType_Delimited;
- upb_Decode_AddUnknownVarints(d, msg, tag, (uint32_t)(ptr - start));
- if (!_upb_Message_AddUnknown(msg, start, ptr - start, &d->arena)) {
- decode_err(d, kUpb_DecodeStatus_OutOfMemory);
- }
- } else {
- _upb_Map_Set(map, &ent.k, map->key_size, &ent.v, map->val_size, &d->arena);
- }
- return ptr;
-}
-
-static const char* decode_tomsg(upb_Decoder* d, const char* ptr,
- upb_Message* msg, const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* field, wireval* val,
- int op) {
- void* mem = UPB_PTR_AT(msg, field->offset, void);
- int type = field->descriptortype;
-
- if (UPB_UNLIKELY(op == OP_ENUM) &&
- !decode_checkenum(d, ptr, msg, subs[field->submsg_index].subenum, field,
- val)) {
- return ptr;
- }
-
- /* Set presence if necessary. */
- if (field->presence > 0) {
- _upb_sethas_field(msg, field);
- } else if (field->presence < 0) {
- /* Oneof case */
- uint32_t* oneof_case = _upb_oneofcase_field(msg, field);
- if (op == OP_SUBMSG && *oneof_case != field->number) {
- memset(mem, 0, sizeof(void*));
- }
- *oneof_case = field->number;
- }
-
- /* Store into message. */
- switch (op) {
- case OP_SUBMSG: {
- upb_Message** submsgp = mem;
- upb_Message* submsg = *submsgp;
- if (!submsg) {
- submsg = decode_newsubmsg(d, subs, field);
- *submsgp = submsg;
- }
- if (UPB_UNLIKELY(type == kUpb_FieldType_Group)) {
- ptr = decode_togroup(d, ptr, submsg, subs, field);
- } else {
- ptr = decode_tosubmsg(d, ptr, submsg, subs, field, val->size);
- }
- break;
- }
- case OP_STRING:
- decode_verifyutf8(d, ptr, val->size);
- /* Fallthrough. */
- case OP_BYTES:
- return decode_readstr(d, ptr, val->size, mem);
- case OP_SCALAR_LG2(3):
- memcpy(mem, val, 8);
- break;
- case OP_ENUM:
- case OP_SCALAR_LG2(2):
- memcpy(mem, val, 4);
- break;
- case OP_SCALAR_LG2(0):
- memcpy(mem, val, 1);
- break;
- default:
- UPB_UNREACHABLE();
- }
-
- return ptr;
-}
-
-UPB_NOINLINE
-const char* decode_checkrequired(upb_Decoder* d, const char* ptr,
- const upb_Message* msg,
- const upb_MiniTable* l) {
- assert(l->required_count);
- if (UPB_LIKELY((d->options & kUpb_DecodeOption_CheckRequired) == 0)) {
- return ptr;
- }
- uint64_t msg_head;
- memcpy(&msg_head, msg, 8);
- msg_head = _upb_BigEndian_Swap64(msg_head);
- if (upb_MiniTable_requiredmask(l) & ~msg_head) {
- d->missing_required = true;
- }
- return ptr;
-}
-
-UPB_FORCEINLINE
-static bool decode_tryfastdispatch(upb_Decoder* d, const char** ptr,
- upb_Message* msg,
- const upb_MiniTable* layout) {
-#if UPB_FASTTABLE
- if (layout && layout->table_mask != (unsigned char)-1) {
- uint16_t tag = fastdecode_loadtag(*ptr);
- intptr_t table = decode_totable(layout);
- *ptr = fastdecode_tagdispatch(d, *ptr, msg, table, 0, tag);
- return true;
- }
-#endif
- return false;
-}
-
-static const char* decode_msgset(upb_Decoder* d, const char* ptr,
- upb_Message* msg,
- const upb_MiniTable* layout) {
- // We create a temporary upb_MiniTable here and abuse its fields as temporary
- // storage, to avoid creating lots of MessageSet-specific parsing code-paths:
- // 1. We store 'layout' in item_layout.subs. We will need this later as
- // a key to look up extensions for this MessageSet.
- // 2. We use item_layout.fields as temporary storage to store the extension
- // we
- // found when parsing the type id.
- upb_MiniTable item_layout = {
- .subs = (const upb_MiniTable_Sub[]){{.submsg = layout}},
- .fields = NULL,
- .size = 0,
- .field_count = 0,
- .ext = kUpb_ExtMode_IsMessageSet_ITEM,
- .dense_below = 0,
- .table_mask = -1};
- return decode_group(d, ptr, msg, &item_layout, 1);
-}
-
-static const upb_MiniTable_Field* decode_findfield(upb_Decoder* d,
- const upb_MiniTable* l,
- uint32_t field_number,
- int* last_field_index) {
- static upb_MiniTable_Field none = {0, 0, 0, 0, 0, 0};
- if (l == NULL) return &none;
-
- size_t idx = ((size_t)field_number) - 1; // 0 wraps to SIZE_MAX
- if (idx < l->dense_below) {
- /* Fastest case: index into dense fields. */
- goto found;
- }
-
- if (l->dense_below < l->field_count) {
- /* Linear search non-dense fields. Resume scanning from last_field_index
- * since fields are usually in order. */
- int last = *last_field_index;
- for (idx = last; idx < l->field_count; idx++) {
- if (l->fields[idx].number == field_number) {
- goto found;
- }
- }
-
- for (idx = l->dense_below; idx < last; idx++) {
- if (l->fields[idx].number == field_number) {
- goto found;
- }
- }
- }
-
- if (d->extreg) {
- switch (l->ext) {
- case kUpb_ExtMode_Extendable: {
- const upb_MiniTable_Extension* ext =
- _upb_extreg_get(d->extreg, l, field_number);
- if (ext) return &ext->field;
- break;
- }
- case kUpb_ExtMode_IsMessageSet:
- if (field_number == _UPB_MSGSET_ITEM) {
- static upb_MiniTable_Field item = {0, 0, 0, 0, TYPE_MSGSET_ITEM, 0};
- return &item;
- }
- break;
- case kUpb_ExtMode_IsMessageSet_ITEM:
- switch (field_number) {
- case _UPB_MSGSET_TYPEID: {
- static upb_MiniTable_Field type_id = {
- 0, 0, 0, 0, TYPE_MSGSET_TYPE_ID, 0};
- return &type_id;
- }
- case _UPB_MSGSET_MESSAGE:
- if (l->fields) {
- // We saw type_id previously and succeeded in looking up msg.
- return l->fields;
- } else {
- // TODO: out of order MessageSet.
- // This is a very rare case: all serializers will emit in-order
- // MessageSets. To hit this case there has to be some kind of
- // re-ordering proxy. We should eventually handle this case, but
- // not today.
- }
- break;
- }
- }
- }
-
- return &none; /* Unknown field. */
-
-found:
- UPB_ASSERT(l->fields[idx].number == field_number);
- *last_field_index = idx;
- return &l->fields[idx];
-}
-
-UPB_FORCEINLINE
-static const char* decode_wireval(upb_Decoder* d, const char* ptr,
- const upb_MiniTable_Field* field,
- int wire_type, wireval* val, int* op) {
- switch (wire_type) {
- case kUpb_WireType_Varint:
- ptr = decode_varint64(d, ptr, &val->uint64_val);
- *op = varint_ops[field->descriptortype];
- decode_munge(field->descriptortype, val);
- return ptr;
- case kUpb_WireType_32Bit:
- memcpy(&val->uint32_val, ptr, 4);
- val->uint32_val = _upb_BigEndian_Swap32(val->uint32_val);
- *op = OP_SCALAR_LG2(2);
- if (((1 << field->descriptortype) & FIXED32_OK_MASK) == 0) {
- *op = OP_UNKNOWN;
- }
- return ptr + 4;
- case kUpb_WireType_64Bit:
- memcpy(&val->uint64_val, ptr, 8);
- val->uint64_val = _upb_BigEndian_Swap64(val->uint64_val);
- *op = OP_SCALAR_LG2(3);
- if (((1 << field->descriptortype) & FIXED64_OK_MASK) == 0) {
- *op = OP_UNKNOWN;
- }
- return ptr + 8;
- case kUpb_WireType_Delimited: {
- int ndx = field->descriptortype;
- uint64_t size;
- if (upb_FieldMode_Get(field) == kUpb_FieldMode_Array) ndx += TYPE_COUNT;
- ptr = decode_varint64(d, ptr, &size);
- if (size >= INT32_MAX || ptr - d->end + (int32_t)size > d->limit) {
- break; /* Length overflow. */
- }
- *op = delim_ops[ndx];
- val->size = size;
- return ptr;
- }
- case kUpb_WireType_StartGroup:
- val->uint32_val = field->number;
- if (field->descriptortype == kUpb_FieldType_Group) {
- *op = OP_SUBMSG;
- } else if (field->descriptortype == TYPE_MSGSET_ITEM) {
- *op = OP_MSGSET_ITEM;
- } else {
- *op = OP_UNKNOWN;
- }
- return ptr;
- default:
- break;
- }
- return decode_err(d, kUpb_DecodeStatus_Malformed);
-}
-
-UPB_FORCEINLINE
-static const char* decode_known(upb_Decoder* d, const char* ptr,
- upb_Message* msg, const upb_MiniTable* layout,
- const upb_MiniTable_Field* field, int op,
- wireval* val) {
- const upb_MiniTable_Sub* subs = layout->subs;
- uint8_t mode = field->mode;
-
- if (UPB_UNLIKELY(mode & kUpb_LabelFlags_IsExtension)) {
- const upb_MiniTable_Extension* ext_layout =
- (const upb_MiniTable_Extension*)field;
- upb_Message_Extension* ext =
- _upb_Message_Getorcreateext(msg, ext_layout, &d->arena);
- if (UPB_UNLIKELY(!ext)) return decode_err(d, kUpb_DecodeStatus_OutOfMemory);
- msg = &ext->data;
- subs = &ext->ext->sub;
- }
-
- switch (mode & kUpb_FieldMode_Mask) {
- case kUpb_FieldMode_Array:
- return decode_toarray(d, ptr, msg, subs, field, val, op);
- case kUpb_FieldMode_Map:
- return decode_tomap(d, ptr, msg, subs, field, val);
- case kUpb_FieldMode_Scalar:
- return decode_tomsg(d, ptr, msg, subs, field, val, op);
- default:
- UPB_UNREACHABLE();
- }
-}
-
-static const char* decode_reverse_skip_varint(const char* ptr, uint32_t val) {
- uint32_t seen = 0;
- do {
- ptr--;
- seen <<= 7;
- seen |= *ptr & 0x7f;
- } while (seen != val);
- return ptr;
-}
-
-static const char* decode_unknown(upb_Decoder* d, const char* ptr,
- upb_Message* msg, int field_number,
- int wire_type, wireval val) {
- if (field_number == 0) return decode_err(d, kUpb_DecodeStatus_Malformed);
-
- // Since unknown fields are the uncommon case, we do a little extra work here
- // to walk backwards through the buffer to find the field start. This frees
- // up a register in the fast paths (when the field is known), which leads to
- // significant speedups in benchmarks.
- const char* start = ptr;
-
- if (wire_type == kUpb_WireType_Delimited) ptr += val.size;
- if (msg) {
- switch (wire_type) {
- case kUpb_WireType_Varint:
- case kUpb_WireType_Delimited:
- start--;
- while (start[-1] & 0x80) start--;
- break;
- case kUpb_WireType_32Bit:
- start -= 4;
- break;
- case kUpb_WireType_64Bit:
- start -= 8;
- break;
- default:
- break;
- }
-
- assert(start == d->debug_valstart);
- uint32_t tag = ((uint32_t)field_number << 3) | wire_type;
- start = decode_reverse_skip_varint(start, tag);
- assert(start == d->debug_tagstart);
-
- if (wire_type == kUpb_WireType_StartGroup) {
- d->unknown = start;
- d->unknown_msg = msg;
- ptr = decode_group(d, ptr, NULL, NULL, field_number);
- start = d->unknown;
- d->unknown_msg = NULL;
- d->unknown = NULL;
- }
- if (!_upb_Message_AddUnknown(msg, start, ptr - start, &d->arena)) {
- return decode_err(d, kUpb_DecodeStatus_OutOfMemory);
- }
- } else if (wire_type == kUpb_WireType_StartGroup) {
- ptr = decode_group(d, ptr, NULL, NULL, field_number);
- }
- return ptr;
-}
-
-UPB_NOINLINE
-static const char* decode_msg(upb_Decoder* d, const char* ptr, upb_Message* msg,
- const upb_MiniTable* layout) {
- int last_field_index = 0;
-
-#if UPB_FASTTABLE
- // The first time we want to skip fast dispatch, because we may have just been
- // invoked by the fast parser to handle a case that it bailed on.
- if (!decode_isdone(d, &ptr)) goto nofast;
-#endif
-
- while (!decode_isdone(d, &ptr)) {
- uint32_t tag;
- const upb_MiniTable_Field* field;
- int field_number;
- int wire_type;
- wireval val;
- int op;
-
- if (decode_tryfastdispatch(d, &ptr, msg, layout)) break;
-
-#if UPB_FASTTABLE
- nofast:
-#endif
-
-#ifndef NDEBUG
- d->debug_tagstart = ptr;
-#endif
-
- UPB_ASSERT(ptr < d->limit_ptr);
- ptr = decode_tag(d, ptr, &tag);
- field_number = tag >> 3;
- wire_type = tag & 7;
-
-#ifndef NDEBUG
- d->debug_valstart = ptr;
-#endif
-
- if (wire_type == kUpb_WireType_EndGroup) {
- d->end_group = field_number;
- return ptr;
- }
-
- field = decode_findfield(d, layout, field_number, &last_field_index);
- ptr = decode_wireval(d, ptr, field, wire_type, &val, &op);
-
- if (op >= 0) {
- ptr = decode_known(d, ptr, msg, layout, field, op, &val);
- } else {
- switch (op) {
- case OP_UNKNOWN:
- ptr = decode_unknown(d, ptr, msg, field_number, wire_type, val);
- break;
- case OP_MSGSET_ITEM:
- ptr = decode_msgset(d, ptr, msg, layout);
- break;
- case OP_MSGSET_TYPEID: {
- const upb_MiniTable_Extension* ext = _upb_extreg_get(
- d->extreg, layout->subs[0].submsg, val.uint64_val);
- if (ext) ((upb_MiniTable*)layout)->fields = &ext->field;
- break;
- }
- }
- }
- }
-
- return UPB_UNLIKELY(layout && layout->required_count)
- ? decode_checkrequired(d, ptr, msg, layout)
- : ptr;
-}
-
-const char* fastdecode_generic(struct upb_Decoder* d, const char* ptr,
- upb_Message* msg, intptr_t table,
- uint64_t hasbits, uint64_t data) {
- (void)data;
- *(uint32_t*)msg |= hasbits;
- return decode_msg(d, ptr, msg, decode_totablep(table));
-}
-
-static upb_DecodeStatus decode_top(struct upb_Decoder* d, const char* buf,
- void* msg, const upb_MiniTable* l) {
- if (!decode_tryfastdispatch(d, &buf, msg, l)) {
- decode_msg(d, buf, msg, l);
- }
- if (d->end_group != DECODE_NOGROUP) return kUpb_DecodeStatus_Malformed;
- if (d->missing_required) return kUpb_DecodeStatus_MissingRequired;
- return kUpb_DecodeStatus_Ok;
-}
-
-upb_DecodeStatus upb_Decode(const char* buf, size_t size, void* msg,
- const upb_MiniTable* l,
- const upb_ExtensionRegistry* extreg, int options,
- upb_Arena* arena) {
- upb_Decoder state;
- unsigned depth = (unsigned)options >> 16;
-
- if (size <= 16) {
- memset(&state.patch, 0, 32);
- if (size) memcpy(&state.patch, buf, size);
- buf = state.patch;
- state.end = buf + size;
- state.limit = 0;
- options &= ~kUpb_DecodeOption_AliasString; // Can't alias patch buf.
- } else {
- state.end = buf + size - 16;
- state.limit = 16;
- }
-
- state.extreg = extreg;
- state.limit_ptr = state.end;
- state.unknown_msg = NULL;
- state.depth = depth ? depth : 64;
- state.end_group = DECODE_NOGROUP;
- state.options = (uint16_t)options;
- state.missing_required = false;
- state.arena.head = arena->head;
- state.arena.last_size = arena->last_size;
- state.arena.cleanup_metadata = arena->cleanup_metadata;
- state.arena.parent = arena;
-
- upb_DecodeStatus status = UPB_SETJMP(state.err);
- if (UPB_LIKELY(status == kUpb_DecodeStatus_Ok)) {
- status = decode_top(&state, buf, msg, l);
- }
-
- arena->head.ptr = state.arena.head.ptr;
- arena->head.end = state.arena.head.end;
- arena->cleanup_metadata = state.arena.cleanup_metadata;
- return status;
-}
-
-#undef OP_UNKNOWN
-#undef OP_SKIP
-#undef OP_SCALAR_LG2
-#undef OP_FIXPCK_LG2
-#undef OP_VARPCK_LG2
-#undef OP_STRING
-#undef OP_BYTES
-#undef OP_SUBMSG
-
-/** upb/encode.c ************************************************************/
-/* We encode backwards, to avoid pre-computing lengths (one-pass encode). */
-
-
-#include <setjmp.h>
-#include <string.h>
-
-
-/* Must be last. */
-
-#define UPB_PB_VARINT_MAX_LEN 10
-
-UPB_NOINLINE
-static size_t encode_varint64(uint64_t val, char* buf) {
- size_t i = 0;
- do {
- uint8_t byte = val & 0x7fU;
- val >>= 7;
- if (val) byte |= 0x80U;
- buf[i++] = byte;
- } while (val);
- return i;
-}
-
-static uint32_t encode_zz32(int32_t n) {
- return ((uint32_t)n << 1) ^ (n >> 31);
-}
-static uint64_t encode_zz64(int64_t n) {
- return ((uint64_t)n << 1) ^ (n >> 63);
-}
-
-typedef struct {
- jmp_buf err;
- upb_alloc* alloc;
- char *buf, *ptr, *limit;
- int options;
- int depth;
- _upb_mapsorter sorter;
-} upb_encstate;
-
-static size_t upb_roundup_pow2(size_t bytes) {
- size_t ret = 128;
- while (ret < bytes) {
- ret *= 2;
- }
- return ret;
-}
-
-UPB_NORETURN static void encode_err(upb_encstate* e) { UPB_LONGJMP(e->err, 1); }
-
-UPB_NOINLINE
-static void encode_growbuffer(upb_encstate* e, size_t bytes) {
- size_t old_size = e->limit - e->buf;
- size_t new_size = upb_roundup_pow2(bytes + (e->limit - e->ptr));
- char* new_buf = upb_realloc(e->alloc, e->buf, old_size, new_size);
-
- if (!new_buf) encode_err(e);
-
- /* We want previous data at the end, realloc() put it at the beginning. */
- if (old_size > 0) {
- memmove(new_buf + new_size - old_size, e->buf, old_size);
- }
-
- e->ptr = new_buf + new_size - (e->limit - e->ptr);
- e->limit = new_buf + new_size;
- e->buf = new_buf;
-
- e->ptr -= bytes;
-}
-
-/* Call to ensure that at least "bytes" bytes are available for writing at
- * e->ptr. Returns false if the bytes could not be allocated. */
-UPB_FORCEINLINE
-static void encode_reserve(upb_encstate* e, size_t bytes) {
- if ((size_t)(e->ptr - e->buf) < bytes) {
- encode_growbuffer(e, bytes);
- return;
- }
-
- e->ptr -= bytes;
-}
-
-/* Writes the given bytes to the buffer, handling reserve/advance. */
-static void encode_bytes(upb_encstate* e, const void* data, size_t len) {
- if (len == 0) return; /* memcpy() with zero size is UB */
- encode_reserve(e, len);
- memcpy(e->ptr, data, len);
-}
-
-static void encode_fixed64(upb_encstate* e, uint64_t val) {
- val = _upb_BigEndian_Swap64(val);
- encode_bytes(e, &val, sizeof(uint64_t));
-}
-
-static void encode_fixed32(upb_encstate* e, uint32_t val) {
- val = _upb_BigEndian_Swap32(val);
- encode_bytes(e, &val, sizeof(uint32_t));
-}
-
-UPB_NOINLINE
-static void encode_longvarint(upb_encstate* e, uint64_t val) {
- size_t len;
- char* start;
-
- encode_reserve(e, UPB_PB_VARINT_MAX_LEN);
- len = encode_varint64(val, e->ptr);
- start = e->ptr + UPB_PB_VARINT_MAX_LEN - len;
- memmove(start, e->ptr, len);
- e->ptr = start;
-}
-
-UPB_FORCEINLINE
-static void encode_varint(upb_encstate* e, uint64_t val) {
- if (val < 128 && e->ptr != e->buf) {
- --e->ptr;
- *e->ptr = val;
- } else {
- encode_longvarint(e, val);
- }
-}
-
-static void encode_double(upb_encstate* e, double d) {
- uint64_t u64;
- UPB_ASSERT(sizeof(double) == sizeof(uint64_t));
- memcpy(&u64, &d, sizeof(uint64_t));
- encode_fixed64(e, u64);
-}
-
-static void encode_float(upb_encstate* e, float d) {
- uint32_t u32;
- UPB_ASSERT(sizeof(float) == sizeof(uint32_t));
- memcpy(&u32, &d, sizeof(uint32_t));
- encode_fixed32(e, u32);
-}
-
-static void encode_tag(upb_encstate* e, uint32_t field_number,
- uint8_t wire_type) {
- encode_varint(e, (field_number << 3) | wire_type);
-}
-
-static void encode_fixedarray(upb_encstate* e, const upb_Array* arr,
- size_t elem_size, uint32_t tag) {
- size_t bytes = arr->len * elem_size;
- const char* data = _upb_array_constptr(arr);
- const char* ptr = data + bytes - elem_size;
-
- if (tag || !_upb_IsLittleEndian()) {
- while (true) {
- if (elem_size == 4) {
- uint32_t val;
- memcpy(&val, ptr, sizeof(val));
- val = _upb_BigEndian_Swap32(val);
- encode_bytes(e, &val, elem_size);
- } else {
- UPB_ASSERT(elem_size == 8);
- uint64_t val;
- memcpy(&val, ptr, sizeof(val));
- val = _upb_BigEndian_Swap64(val);
- encode_bytes(e, &val, elem_size);
- }
-
- if (tag) encode_varint(e, tag);
- if (ptr == data) break;
- ptr -= elem_size;
- }
- } else {
- encode_bytes(e, data, bytes);
- }
-}
-
-static void encode_message(upb_encstate* e, const upb_Message* msg,
- const upb_MiniTable* m, size_t* size);
-
-static void encode_scalar(upb_encstate* e, const void* _field_mem,
- const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* f) {
- const char* field_mem = _field_mem;
- int wire_type;
-
-#define CASE(ctype, type, wtype, encodeval) \
- { \
- ctype val = *(ctype*)field_mem; \
- encode_##type(e, encodeval); \
- wire_type = wtype; \
- break; \
- }
-
- switch (f->descriptortype) {
- case kUpb_FieldType_Double:
- CASE(double, double, kUpb_WireType_64Bit, val);
- case kUpb_FieldType_Float:
- CASE(float, float, kUpb_WireType_32Bit, val);
- case kUpb_FieldType_Int64:
- case kUpb_FieldType_UInt64:
- CASE(uint64_t, varint, kUpb_WireType_Varint, val);
- case kUpb_FieldType_UInt32:
- CASE(uint32_t, varint, kUpb_WireType_Varint, val);
- case kUpb_FieldType_Int32:
- case kUpb_FieldType_Enum:
- CASE(int32_t, varint, kUpb_WireType_Varint, (int64_t)val);
- case kUpb_FieldType_SFixed64:
- case kUpb_FieldType_Fixed64:
- CASE(uint64_t, fixed64, kUpb_WireType_64Bit, val);
- case kUpb_FieldType_Fixed32:
- case kUpb_FieldType_SFixed32:
- CASE(uint32_t, fixed32, kUpb_WireType_32Bit, val);
- case kUpb_FieldType_Bool:
- CASE(bool, varint, kUpb_WireType_Varint, val);
- case kUpb_FieldType_SInt32:
- CASE(int32_t, varint, kUpb_WireType_Varint, encode_zz32(val));
- case kUpb_FieldType_SInt64:
- CASE(int64_t, varint, kUpb_WireType_Varint, encode_zz64(val));
- case kUpb_FieldType_String:
- case kUpb_FieldType_Bytes: {
- upb_StringView view = *(upb_StringView*)field_mem;
- encode_bytes(e, view.data, view.size);
- encode_varint(e, view.size);
- wire_type = kUpb_WireType_Delimited;
- break;
- }
- case kUpb_FieldType_Group: {
- size_t size;
- void* submsg = *(void**)field_mem;
- const upb_MiniTable* subm = subs[f->submsg_index].submsg;
- if (submsg == NULL) {
- return;
- }
- if (--e->depth == 0) encode_err(e);
- encode_tag(e, f->number, kUpb_WireType_EndGroup);
- encode_message(e, submsg, subm, &size);
- wire_type = kUpb_WireType_StartGroup;
- e->depth++;
- break;
- }
- case kUpb_FieldType_Message: {
- size_t size;
- void* submsg = *(void**)field_mem;
- const upb_MiniTable* subm = subs[f->submsg_index].submsg;
- if (submsg == NULL) {
- return;
- }
- if (--e->depth == 0) encode_err(e);
- encode_message(e, submsg, subm, &size);
- encode_varint(e, size);
- wire_type = kUpb_WireType_Delimited;
- e->depth++;
- break;
- }
- default:
- UPB_UNREACHABLE();
- }
-#undef CASE
-
- encode_tag(e, f->number, wire_type);
-}
-
-static void encode_array(upb_encstate* e, const upb_Message* msg,
- const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* f) {
- const upb_Array* arr = *UPB_PTR_AT(msg, f->offset, upb_Array*);
- bool packed = f->mode & kUpb_LabelFlags_IsPacked;
- size_t pre_len = e->limit - e->ptr;
-
- if (arr == NULL || arr->len == 0) {
- return;
- }
-
-#define VARINT_CASE(ctype, encode) \
- { \
- const ctype* start = _upb_array_constptr(arr); \
- const ctype* ptr = start + arr->len; \
- uint32_t tag = packed ? 0 : (f->number << 3) | kUpb_WireType_Varint; \
- do { \
- ptr--; \
- encode_varint(e, encode); \
- if (tag) encode_varint(e, tag); \
- } while (ptr != start); \
- } \
- break;
-
-#define TAG(wire_type) (packed ? 0 : (f->number << 3 | wire_type))
-
- switch (f->descriptortype) {
- case kUpb_FieldType_Double:
- encode_fixedarray(e, arr, sizeof(double), TAG(kUpb_WireType_64Bit));
- break;
- case kUpb_FieldType_Float:
- encode_fixedarray(e, arr, sizeof(float), TAG(kUpb_WireType_32Bit));
- break;
- case kUpb_FieldType_SFixed64:
- case kUpb_FieldType_Fixed64:
- encode_fixedarray(e, arr, sizeof(uint64_t), TAG(kUpb_WireType_64Bit));
- break;
- case kUpb_FieldType_Fixed32:
- case kUpb_FieldType_SFixed32:
- encode_fixedarray(e, arr, sizeof(uint32_t), TAG(kUpb_WireType_32Bit));
- break;
- case kUpb_FieldType_Int64:
- case kUpb_FieldType_UInt64:
- VARINT_CASE(uint64_t, *ptr);
- case kUpb_FieldType_UInt32:
- VARINT_CASE(uint32_t, *ptr);
- case kUpb_FieldType_Int32:
- case kUpb_FieldType_Enum:
- VARINT_CASE(int32_t, (int64_t)*ptr);
- case kUpb_FieldType_Bool:
- VARINT_CASE(bool, *ptr);
- case kUpb_FieldType_SInt32:
- VARINT_CASE(int32_t, encode_zz32(*ptr));
- case kUpb_FieldType_SInt64:
- VARINT_CASE(int64_t, encode_zz64(*ptr));
- case kUpb_FieldType_String:
- case kUpb_FieldType_Bytes: {
- const upb_StringView* start = _upb_array_constptr(arr);
- const upb_StringView* ptr = start + arr->len;
- do {
- ptr--;
- encode_bytes(e, ptr->data, ptr->size);
- encode_varint(e, ptr->size);
- encode_tag(e, f->number, kUpb_WireType_Delimited);
- } while (ptr != start);
- return;
- }
- case kUpb_FieldType_Group: {
- const void* const* start = _upb_array_constptr(arr);
- const void* const* ptr = start + arr->len;
- const upb_MiniTable* subm = subs[f->submsg_index].submsg;
- if (--e->depth == 0) encode_err(e);
- do {
- size_t size;
- ptr--;
- encode_tag(e, f->number, kUpb_WireType_EndGroup);
- encode_message(e, *ptr, subm, &size);
- encode_tag(e, f->number, kUpb_WireType_StartGroup);
- } while (ptr != start);
- e->depth++;
- return;
- }
- case kUpb_FieldType_Message: {
- const void* const* start = _upb_array_constptr(arr);
- const void* const* ptr = start + arr->len;
- const upb_MiniTable* subm = subs[f->submsg_index].submsg;
- if (--e->depth == 0) encode_err(e);
- do {
- size_t size;
- ptr--;
- encode_message(e, *ptr, subm, &size);
- encode_varint(e, size);
- encode_tag(e, f->number, kUpb_WireType_Delimited);
- } while (ptr != start);
- e->depth++;
- return;
- }
- }
-#undef VARINT_CASE
-
- if (packed) {
- encode_varint(e, e->limit - e->ptr - pre_len);
- encode_tag(e, f->number, kUpb_WireType_Delimited);
- }
-}
-
-static void encode_mapentry(upb_encstate* e, uint32_t number,
- const upb_MiniTable* layout,
- const upb_MapEntry* ent) {
- const upb_MiniTable_Field* key_field = &layout->fields[0];
- const upb_MiniTable_Field* val_field = &layout->fields[1];
- size_t pre_len = e->limit - e->ptr;
- size_t size;
- encode_scalar(e, &ent->v, layout->subs, val_field);
- encode_scalar(e, &ent->k, layout->subs, key_field);
- size = (e->limit - e->ptr) - pre_len;
- encode_varint(e, size);
- encode_tag(e, number, kUpb_WireType_Delimited);
-}
-
-static void encode_map(upb_encstate* e, const upb_Message* msg,
- const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* f) {
- const upb_Map* map = *UPB_PTR_AT(msg, f->offset, const upb_Map*);
- const upb_MiniTable* layout = subs[f->submsg_index].submsg;
- UPB_ASSERT(layout->field_count == 2);
-
- if (map == NULL) return;
-
- if (e->options & kUpb_Encode_Deterministic) {
- _upb_sortedmap sorted;
- _upb_mapsorter_pushmap(&e->sorter, layout->fields[0].descriptortype, map,
- &sorted);
- upb_MapEntry ent;
- while (_upb_sortedmap_next(&e->sorter, map, &sorted, &ent)) {
- encode_mapentry(e, f->number, layout, &ent);
- }
- _upb_mapsorter_popmap(&e->sorter, &sorted);
- } else {
- upb_strtable_iter i;
- upb_strtable_begin(&i, &map->table);
- for (; !upb_strtable_done(&i); upb_strtable_next(&i)) {
- upb_StringView key = upb_strtable_iter_key(&i);
- const upb_value val = upb_strtable_iter_value(&i);
- upb_MapEntry ent;
- _upb_map_fromkey(key, &ent.k, map->key_size);
- _upb_map_fromvalue(val, &ent.v, map->val_size);
- encode_mapentry(e, f->number, layout, &ent);
- }
- }
-}
-
-static bool encode_shouldencode(upb_encstate* e, const upb_Message* msg,
- const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* f) {
- if (f->presence == 0) {
- /* Proto3 presence or map/array. */
- const void* mem = UPB_PTR_AT(msg, f->offset, void);
- switch (f->mode >> kUpb_FieldRep_Shift) {
- case kUpb_FieldRep_1Byte: {
- char ch;
- memcpy(&ch, mem, 1);
- return ch != 0;
- }
-#if UINTPTR_MAX == 0xffffffff
- case kUpb_FieldRep_Pointer:
-#endif
- case kUpb_FieldRep_4Byte: {
- uint32_t u32;
- memcpy(&u32, mem, 4);
- return u32 != 0;
- }
-#if UINTPTR_MAX != 0xffffffff
- case kUpb_FieldRep_Pointer:
-#endif
- case kUpb_FieldRep_8Byte: {
- uint64_t u64;
- memcpy(&u64, mem, 8);
- return u64 != 0;
- }
- case kUpb_FieldRep_StringView: {
- const upb_StringView* str = (const upb_StringView*)mem;
- return str->size != 0;
- }
- default:
- UPB_UNREACHABLE();
- }
- } else if (f->presence > 0) {
- /* Proto2 presence: hasbit. */
- return _upb_hasbit_field(msg, f);
- } else {
- /* Field is in a oneof. */
- return _upb_getoneofcase_field(msg, f) == f->number;
- }
-}
-
-static void encode_field(upb_encstate* e, const upb_Message* msg,
- const upb_MiniTable_Sub* subs,
- const upb_MiniTable_Field* field) {
- switch (upb_FieldMode_Get(field)) {
- case kUpb_FieldMode_Array:
- encode_array(e, msg, subs, field);
- break;
- case kUpb_FieldMode_Map:
- encode_map(e, msg, subs, field);
- break;
- case kUpb_FieldMode_Scalar:
- encode_scalar(e, UPB_PTR_AT(msg, field->offset, void), subs, field);
- break;
- default:
- UPB_UNREACHABLE();
- }
-}
-
-/* message MessageSet {
- * repeated group Item = 1 {
- * required int32 type_id = 2;
- * required string message = 3;
- * }
- * } */
-static void encode_msgset_item(upb_encstate* e,
- const upb_Message_Extension* ext) {
- size_t size;
- encode_tag(e, 1, kUpb_WireType_EndGroup);
- encode_message(e, ext->data.ptr, ext->ext->sub.submsg, &size);
- encode_varint(e, size);
- encode_tag(e, 3, kUpb_WireType_Delimited);
- encode_varint(e, ext->ext->field.number);
- encode_tag(e, 2, kUpb_WireType_Varint);
- encode_tag(e, 1, kUpb_WireType_StartGroup);
-}
-
-static void encode_message(upb_encstate* e, const upb_Message* msg,
- const upb_MiniTable* m, size_t* size) {
- size_t pre_len = e->limit - e->ptr;
-
- if ((e->options & kUpb_Encode_CheckRequired) && m->required_count) {
- uint64_t msg_head;
- memcpy(&msg_head, msg, 8);
- msg_head = _upb_BigEndian_Swap64(msg_head);
- if (upb_MiniTable_requiredmask(m) & ~msg_head) {
- encode_err(e);
- }
- }
-
- if ((e->options & kUpb_Encode_SkipUnknown) == 0) {
- size_t unknown_size;
- const char* unknown = upb_Message_GetUnknown(msg, &unknown_size);
-
- if (unknown) {
- encode_bytes(e, unknown, unknown_size);
- }
- }
-
- if (m->ext != kUpb_ExtMode_NonExtendable) {
- /* Encode all extensions together. Unlike C++, we do not attempt to keep
- * these in field number order relative to normal fields or even to each
- * other. */
- size_t ext_count;
- const upb_Message_Extension* ext = _upb_Message_Getexts(msg, &ext_count);
- if (ext_count) {
- const upb_Message_Extension* end = ext + ext_count;
- for (; ext != end; ext++) {
- if (UPB_UNLIKELY(m->ext == kUpb_ExtMode_IsMessageSet)) {
- encode_msgset_item(e, ext);
- } else {
- encode_field(e, &ext->data, &ext->ext->sub, &ext->ext->field);
- }
- }
- }
- }
-
- if (m->field_count) {
- const upb_MiniTable_Field* f = &m->fields[m->field_count];
- const upb_MiniTable_Field* first = &m->fields[0];
- while (f != first) {
- f--;
- if (encode_shouldencode(e, msg, m->subs, f)) {
- encode_field(e, msg, m->subs, f);
- }
- }
- }
-
- *size = (e->limit - e->ptr) - pre_len;
-}
-
-char* upb_Encode(const void* msg, const upb_MiniTable* l, int options,
- upb_Arena* arena, size_t* size) {
- upb_encstate e;
- unsigned depth = (unsigned)options >> 16;
-
- e.alloc = upb_Arena_Alloc(arena);
- e.buf = NULL;
- e.limit = NULL;
- e.ptr = NULL;
- e.depth = depth ? depth : 64;
- e.options = options;
- _upb_mapsorter_init(&e.sorter);
- char* ret = NULL;
-
- if (UPB_SETJMP(e.err)) {
- *size = 0;
- ret = NULL;
- } else {
- encode_message(&e, msg, l, size);
- *size = e.limit - e.ptr;
- if (*size == 0) {
- static char ch;
- ret = &ch;
- } else {
- UPB_ASSERT(e.ptr);
- ret = e.ptr;
- }
- }
-
- _upb_mapsorter_destroy(&e.sorter);
- return ret;
-}
-
-/** upb/msg.c ************************************************************/
-
-
-/** upb_Message
- * *******************************************************************/
-
-static const size_t overhead = sizeof(upb_Message_InternalData);
-
-static const upb_Message_Internal* upb_Message_Getinternal_const(
- const upb_Message* msg) {
- ptrdiff_t size = sizeof(upb_Message_Internal);
- return (upb_Message_Internal*)((char*)msg - size);
-}
-
-upb_Message* _upb_Message_New(const upb_MiniTable* l, upb_Arena* a) {
- return _upb_Message_New_inl(l, a);
-}
-
-void _upb_Message_Clear(upb_Message* msg, const upb_MiniTable* l) {
- void* mem = UPB_PTR_AT(msg, -sizeof(upb_Message_Internal), char);
- memset(mem, 0, upb_msg_sizeof(l));
-}
-
-static bool realloc_internal(upb_Message* msg, size_t need, upb_Arena* arena) {
- upb_Message_Internal* in = upb_Message_Getinternal(msg);
- if (!in->internal) {
- /* No internal data, allocate from scratch. */
- size_t size = UPB_MAX(128, _upb_Log2CeilingSize(need + overhead));
- upb_Message_InternalData* internal = upb_Arena_Malloc(arena, size);
- if (!internal) return false;
- internal->size = size;
- internal->unknown_end = overhead;
- internal->ext_begin = size;
- in->internal = internal;
- } else if (in->internal->ext_begin - in->internal->unknown_end < need) {
- /* Internal data is too small, reallocate. */
- size_t new_size = _upb_Log2CeilingSize(in->internal->size + need);
- size_t ext_bytes = in->internal->size - in->internal->ext_begin;
- size_t new_ext_begin = new_size - ext_bytes;
- upb_Message_InternalData* internal =
- upb_Arena_Realloc(arena, in->internal, in->internal->size, new_size);
- if (!internal) return false;
- if (ext_bytes) {
- /* Need to move extension data to the end. */
- char* ptr = (char*)internal;
- memmove(ptr + new_ext_begin, ptr + internal->ext_begin, ext_bytes);
- }
- internal->ext_begin = new_ext_begin;
- internal->size = new_size;
- in->internal = internal;
- }
- UPB_ASSERT(in->internal->ext_begin - in->internal->unknown_end >= need);
- return true;
-}
-
-bool _upb_Message_AddUnknown(upb_Message* msg, const char* data, size_t len,
- upb_Arena* arena) {
- if (!realloc_internal(msg, len, arena)) return false;
- upb_Message_Internal* in = upb_Message_Getinternal(msg);
- memcpy(UPB_PTR_AT(in->internal, in->internal->unknown_end, char), data, len);
- in->internal->unknown_end += len;
- return true;
-}
-
-void _upb_Message_DiscardUnknown_shallow(upb_Message* msg) {
- upb_Message_Internal* in = upb_Message_Getinternal(msg);
- if (in->internal) {
- in->internal->unknown_end = overhead;
- }
-}
-
-const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len) {
- const upb_Message_Internal* in = upb_Message_Getinternal_const(msg);
- if (in->internal) {
- *len = in->internal->unknown_end - overhead;
- return (char*)(in->internal + 1);
- } else {
- *len = 0;
- return NULL;
- }
-}
-
-const upb_Message_Extension* _upb_Message_Getexts(const upb_Message* msg,
- size_t* count) {
- const upb_Message_Internal* in = upb_Message_Getinternal_const(msg);
- if (in->internal) {
- *count = (in->internal->size - in->internal->ext_begin) /
- sizeof(upb_Message_Extension);
- return UPB_PTR_AT(in->internal, in->internal->ext_begin, void);
- } else {
- *count = 0;
- return NULL;
- }
-}
-
-const upb_Message_Extension* _upb_Message_Getext(
- const upb_Message* msg, const upb_MiniTable_Extension* e) {
- size_t n;
- const upb_Message_Extension* ext = _upb_Message_Getexts(msg, &n);
-
- /* For now we use linear search exclusively to find extensions. If this
- * becomes an issue due to messages with lots of extensions, we can introduce
- * a table of some sort. */
- for (size_t i = 0; i < n; i++) {
- if (ext[i].ext == e) {
- return &ext[i];
- }
- }
-
- return NULL;
-}
-
-void _upb_Message_Clearext(upb_Message* msg,
- const upb_MiniTable_Extension* ext_l) {
- upb_Message_Internal* in = upb_Message_Getinternal(msg);
- if (!in->internal) return;
- const upb_Message_Extension* base =
- UPB_PTR_AT(in->internal, in->internal->ext_begin, void);
- upb_Message_Extension* ext =
- (upb_Message_Extension*)_upb_Message_Getext(msg, ext_l);
- if (ext) {
- *ext = *base;
- in->internal->ext_begin += sizeof(upb_Message_Extension);
- }
-}
-
-upb_Message_Extension* _upb_Message_Getorcreateext(
- upb_Message* msg, const upb_MiniTable_Extension* e, upb_Arena* arena) {
- upb_Message_Extension* ext =
- (upb_Message_Extension*)_upb_Message_Getext(msg, e);
- if (ext) return ext;
- if (!realloc_internal(msg, sizeof(upb_Message_Extension), arena)) return NULL;
- upb_Message_Internal* in = upb_Message_Getinternal(msg);
- in->internal->ext_begin -= sizeof(upb_Message_Extension);
- ext = UPB_PTR_AT(in->internal, in->internal->ext_begin, void);
- memset(ext, 0, sizeof(upb_Message_Extension));
- ext->ext = e;
- return ext;
-}
-
-size_t upb_Message_ExtensionCount(const upb_Message* msg) {
- size_t count;
- _upb_Message_Getexts(msg, &count);
- return count;
-}
-
-/** upb_Array *****************************************************************/
-
-bool _upb_array_realloc(upb_Array* arr, size_t min_size, upb_Arena* arena) {
- size_t new_size = UPB_MAX(arr->size, 4);
+bool _upb_array_realloc(upb_Array* arr, size_t min_capacity, upb_Arena* arena) {
+ size_t new_capacity = UPB_MAX(arr->capacity, 4);
int elem_size_lg2 = arr->data & 7;
- size_t old_bytes = arr->size << elem_size_lg2;
+ size_t old_bytes = arr->capacity << elem_size_lg2;
size_t new_bytes;
void* ptr = _upb_array_ptr(arr);
/* Log2 ceiling of size. */
- while (new_size < min_size) new_size *= 2;
+ while (new_capacity < min_capacity) new_capacity *= 2;
- new_bytes = new_size << elem_size_lg2;
+ new_bytes = new_capacity << elem_size_lg2;
ptr = upb_Arena_Realloc(arena, ptr, old_bytes, new_bytes);
if (!ptr) {
@@ -2098,7 +291,7 @@
}
arr->data = _upb_tag_arrptr(ptr, elem_size_lg2);
- arr->size = new_size;
+ arr->capacity = new_capacity;
return true;
}
@@ -2125,7 +318,7 @@
upb_Array* arr = getorcreate_array(arr_ptr, elem_size_lg2, arena);
if (!arr) return false;
- size_t elems = arr->len;
+ size_t elems = arr->size;
if (!_upb_Array_Resize(arr, elems + 1, arena)) {
return false;
@@ -2136,144 +329,737 @@
return true;
}
-/** upb_Map *******************************************************************/
-upb_Map* _upb_Map_New(upb_Arena* a, size_t key_size, size_t value_size) {
- upb_Map* map = upb_Arena_Malloc(a, sizeof(upb_Map));
+// Must be last.
- if (!map) {
- return NULL;
- }
-
- upb_strtable_init(&map->table, 4, a);
- map->key_size = key_size;
- map->val_size = value_size;
-
- return map;
-}
-
-static void _upb_mapsorter_getkeys(const void* _a, const void* _b, void* a_key,
- void* b_key, size_t size) {
- const upb_tabent* const* a = _a;
- const upb_tabent* const* b = _b;
- upb_StringView a_tabkey = upb_tabstrview((*a)->key);
- upb_StringView b_tabkey = upb_tabstrview((*b)->key);
- _upb_map_fromkey(a_tabkey, a_key, size);
- _upb_map_fromkey(b_tabkey, b_key, size);
-}
-
-#define UPB_COMPARE_INTEGERS(a, b) ((a) < (b) ? -1 : ((a) == (b) ? 0 : 1))
-
-static int _upb_mapsorter_cmpi64(const void* _a, const void* _b) {
- int64_t a, b;
- _upb_mapsorter_getkeys(_a, _b, &a, &b, 8);
- return UPB_COMPARE_INTEGERS(a, b);
-}
-
-static int _upb_mapsorter_cmpu64(const void* _a, const void* _b) {
- uint64_t a, b;
- _upb_mapsorter_getkeys(_a, _b, &a, &b, 8);
- return UPB_COMPARE_INTEGERS(a, b);
-}
-
-static int _upb_mapsorter_cmpi32(const void* _a, const void* _b) {
- int32_t a, b;
- _upb_mapsorter_getkeys(_a, _b, &a, &b, 4);
- return UPB_COMPARE_INTEGERS(a, b);
-}
-
-static int _upb_mapsorter_cmpu32(const void* _a, const void* _b) {
- uint32_t a, b;
- _upb_mapsorter_getkeys(_a, _b, &a, &b, 4);
- return UPB_COMPARE_INTEGERS(a, b);
-}
-
-static int _upb_mapsorter_cmpbool(const void* _a, const void* _b) {
- bool a, b;
- _upb_mapsorter_getkeys(_a, _b, &a, &b, 1);
- return UPB_COMPARE_INTEGERS(a, b);
-}
-
-static int _upb_mapsorter_cmpstr(const void* _a, const void* _b) {
- upb_StringView a, b;
- _upb_mapsorter_getkeys(_a, _b, &a, &b, UPB_MAPTYPE_STRING);
- size_t common_size = UPB_MIN(a.size, b.size);
- int cmp = memcmp(a.data, b.data, common_size);
- if (cmp) return -cmp;
- return UPB_COMPARE_INTEGERS(a.size, b.size);
-}
-
-#undef UPB_COMPARE_INTEGERS
-
-bool _upb_mapsorter_pushmap(_upb_mapsorter* s, upb_FieldType key_type,
- const upb_Map* map, _upb_sortedmap* sorted) {
- int map_size = _upb_Map_Size(map);
- sorted->start = s->size;
- sorted->pos = sorted->start;
- sorted->end = sorted->start + map_size;
-
- /* Grow s->entries if necessary. */
- if (sorted->end > s->cap) {
- s->cap = _upb_Log2CeilingSize(sorted->end);
- s->entries = realloc(s->entries, s->cap * sizeof(*s->entries));
- if (!s->entries) return false;
- }
-
- s->size = sorted->end;
-
- /* Copy non-empty entries from the table to s->entries. */
- upb_tabent const** dst = &s->entries[sorted->start];
- const upb_tabent* src = map->table.t.entries;
- const upb_tabent* end = src + upb_table_size(&map->table.t);
- for (; src < end; src++) {
- if (!upb_tabent_isempty(src)) {
- *dst = src;
- dst++;
+const char* upb_BufToUint64(const char* ptr, const char* end, uint64_t* val) {
+ uint64_t u64 = 0;
+ while (ptr < end) {
+ unsigned ch = *ptr - '0';
+ if (ch >= 10) break;
+ if (u64 > UINT64_MAX / 10 || u64 * 10 > UINT64_MAX - ch) {
+ return NULL; // integer overflow
}
- }
- UPB_ASSERT(dst == &s->entries[sorted->end]);
-
- /* Sort entries according to the key type. */
-
- int (*compar)(const void*, const void*);
-
- switch (key_type) {
- case kUpb_FieldType_Int64:
- case kUpb_FieldType_SFixed64:
- case kUpb_FieldType_SInt64:
- compar = _upb_mapsorter_cmpi64;
- break;
- case kUpb_FieldType_UInt64:
- case kUpb_FieldType_Fixed64:
- compar = _upb_mapsorter_cmpu64;
- break;
- case kUpb_FieldType_Int32:
- case kUpb_FieldType_SInt32:
- case kUpb_FieldType_SFixed32:
- case kUpb_FieldType_Enum:
- compar = _upb_mapsorter_cmpi32;
- break;
- case kUpb_FieldType_UInt32:
- case kUpb_FieldType_Fixed32:
- compar = _upb_mapsorter_cmpu32;
- break;
- case kUpb_FieldType_Bool:
- compar = _upb_mapsorter_cmpbool;
- break;
- case kUpb_FieldType_String:
- case kUpb_FieldType_Bytes:
- compar = _upb_mapsorter_cmpstr;
- break;
- default:
- UPB_UNREACHABLE();
+ u64 *= 10;
+ u64 += ch;
+ ptr++;
}
- qsort(&s->entries[sorted->start], map_size, sizeof(*s->entries), compar);
- return true;
+ *val = u64;
+ return ptr;
}
-/** upb_ExtensionRegistry
- * ****************************************************************/
+const char* upb_BufToInt64(const char* ptr, const char* end, int64_t* val,
+ bool* is_neg) {
+ bool neg = false;
+ uint64_t u64;
+
+ if (ptr != end && *ptr == '-') {
+ ptr++;
+ neg = true;
+ }
+
+ ptr = upb_BufToUint64(ptr, end, &u64);
+ if (!ptr || u64 > (uint64_t)INT64_MAX + neg) {
+ return NULL; // integer overflow
+ }
+
+ *val = neg ? -u64 : u64;
+ if (is_neg) *is_neg = neg;
+ return ptr;
+}
+
+
+#include <string.h>
+
+
+// Must be last.
+
+/* Strings/bytes are special-cased in maps. */
+static char _upb_CTypeo_mapsize[12] = {
+ 0,
+ 1, /* kUpb_CType_Bool */
+ 4, /* kUpb_CType_Float */
+ 4, /* kUpb_CType_Int32 */
+ 4, /* kUpb_CType_UInt32 */
+ 4, /* kUpb_CType_Enum */
+ sizeof(void*), /* kUpb_CType_Message */
+ 8, /* kUpb_CType_Double */
+ 8, /* kUpb_CType_Int64 */
+ 8, /* kUpb_CType_UInt64 */
+ 0, /* kUpb_CType_String */
+ 0, /* kUpb_CType_Bytes */
+};
+
+upb_Map* upb_Map_New(upb_Arena* a, upb_CType key_type, upb_CType value_type) {
+ return _upb_Map_New(a, _upb_CTypeo_mapsize[key_type],
+ _upb_CTypeo_mapsize[value_type]);
+}
+
+size_t upb_Map_Size(const upb_Map* map) { return _upb_Map_Size(map); }
+
+bool upb_Map_Get(const upb_Map* map, upb_MessageValue key,
+ upb_MessageValue* val) {
+ return _upb_Map_Get(map, &key, map->key_size, val, map->val_size);
+}
+
+void upb_Map_Clear(upb_Map* map) { _upb_Map_Clear(map); }
+
+upb_MapInsertStatus upb_Map_Insert(upb_Map* map, upb_MessageValue key,
+ upb_MessageValue val, upb_Arena* arena) {
+ return (upb_MapInsertStatus)_upb_Map_Insert(map, &key, map->key_size, &val,
+ map->val_size, arena);
+}
+
+bool upb_Map_Delete(upb_Map* map, upb_MessageValue key) {
+ return _upb_Map_Delete(map, &key, map->key_size);
+}
+
+bool upb_MapIterator_Next(const upb_Map* map, size_t* iter) {
+ return _upb_map_next(map, iter);
+}
+
+bool upb_MapIterator_Done(const upb_Map* map, size_t iter) {
+ upb_strtable_iter i;
+ UPB_ASSERT(iter != kUpb_Map_Begin);
+ i.t = &map->table;
+ i.index = iter;
+ return upb_strtable_done(&i);
+}
+
+/* Returns the key and value for this entry of the map. */
+upb_MessageValue upb_MapIterator_Key(const upb_Map* map, size_t iter) {
+ upb_strtable_iter i;
+ upb_MessageValue ret;
+ i.t = &map->table;
+ i.index = iter;
+ _upb_map_fromkey(upb_strtable_iter_key(&i), &ret, map->key_size);
+ return ret;
+}
+
+upb_MessageValue upb_MapIterator_Value(const upb_Map* map, size_t iter) {
+ upb_strtable_iter i;
+ upb_MessageValue ret;
+ i.t = &map->table;
+ i.index = iter;
+ _upb_map_fromvalue(upb_strtable_iter_value(&i), &ret, map->val_size);
+ return ret;
+}
+
+/* void upb_MapIterator_SetValue(upb_Map *map, size_t iter, upb_MessageValue
+ * value); */
+/* This file was generated by upbc (the upb compiler) from the input
+ * file:
+ *
+ * google/protobuf/descriptor.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated. */
+
+#include <stddef.h>
+
+
+static const upb_MiniTable_Sub google_protobuf_FileDescriptorSet_submsgs[1] = {
+ {.submsg = &google_protobuf_FileDescriptorProto_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_FileDescriptorSet__fields[1] = {
+ {1, UPB_SIZE(0, 0), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_FileDescriptorSet_msg_init = {
+ &google_protobuf_FileDescriptorSet_submsgs[0],
+ &google_protobuf_FileDescriptorSet__fields[0],
+ UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_FileDescriptorProto_submsgs[6] = {
+ {.submsg = &google_protobuf_DescriptorProto_msg_init},
+ {.submsg = &google_protobuf_EnumDescriptorProto_msg_init},
+ {.submsg = &google_protobuf_ServiceDescriptorProto_msg_init},
+ {.submsg = &google_protobuf_FieldDescriptorProto_msg_init},
+ {.submsg = &google_protobuf_FileOptions_msg_init},
+ {.submsg = &google_protobuf_SourceCodeInfo_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_FileDescriptorProto__fields[13] = {
+ {1, UPB_SIZE(4, 8), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(12, 24), UPB_SIZE(2, 2), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(20, 40), UPB_SIZE(0, 0), kUpb_NoSub, 12, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {4, UPB_SIZE(24, 48), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {5, UPB_SIZE(28, 56), UPB_SIZE(0, 0), 1, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {6, UPB_SIZE(32, 64), UPB_SIZE(0, 0), 2, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {7, UPB_SIZE(36, 72), UPB_SIZE(0, 0), 3, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {8, UPB_SIZE(40, 80), UPB_SIZE(3, 3), 4, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {9, UPB_SIZE(44, 88), UPB_SIZE(4, 4), 5, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {10, UPB_SIZE(48, 96), UPB_SIZE(0, 0), kUpb_NoSub, 5, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {11, UPB_SIZE(52, 104), UPB_SIZE(0, 0), kUpb_NoSub, 5, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {12, UPB_SIZE(56, 112), UPB_SIZE(5, 5), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {13, UPB_SIZE(64, 128), UPB_SIZE(6, 6), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_FileDescriptorProto_msg_init = {
+ &google_protobuf_FileDescriptorProto_submsgs[0],
+ &google_protobuf_FileDescriptorProto__fields[0],
+ UPB_SIZE(72, 144), 13, kUpb_ExtMode_NonExtendable, 13, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_DescriptorProto_submsgs[8] = {
+ {.submsg = &google_protobuf_FieldDescriptorProto_msg_init},
+ {.submsg = &google_protobuf_DescriptorProto_msg_init},
+ {.submsg = &google_protobuf_EnumDescriptorProto_msg_init},
+ {.submsg = &google_protobuf_DescriptorProto_ExtensionRange_msg_init},
+ {.submsg = &google_protobuf_FieldDescriptorProto_msg_init},
+ {.submsg = &google_protobuf_MessageOptions_msg_init},
+ {.submsg = &google_protobuf_OneofDescriptorProto_msg_init},
+ {.submsg = &google_protobuf_DescriptorProto_ReservedRange_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_DescriptorProto__fields[10] = {
+ {1, UPB_SIZE(4, 8), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(12, 24), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(16, 32), UPB_SIZE(0, 0), 1, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {4, UPB_SIZE(20, 40), UPB_SIZE(0, 0), 2, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {5, UPB_SIZE(24, 48), UPB_SIZE(0, 0), 3, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {6, UPB_SIZE(28, 56), UPB_SIZE(0, 0), 4, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {7, UPB_SIZE(32, 64), UPB_SIZE(2, 2), 5, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {8, UPB_SIZE(36, 72), UPB_SIZE(0, 0), 6, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {9, UPB_SIZE(40, 80), UPB_SIZE(0, 0), 7, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {10, UPB_SIZE(44, 88), UPB_SIZE(0, 0), kUpb_NoSub, 12, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_DescriptorProto_msg_init = {
+ &google_protobuf_DescriptorProto_submsgs[0],
+ &google_protobuf_DescriptorProto__fields[0],
+ UPB_SIZE(48, 96), 10, kUpb_ExtMode_NonExtendable, 10, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_DescriptorProto_ExtensionRange_submsgs[1] = {
+ {.submsg = &google_protobuf_ExtensionRangeOptions_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_DescriptorProto_ExtensionRange__fields[3] = {
+ {1, UPB_SIZE(4, 4), UPB_SIZE(1, 1), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(8, 8), UPB_SIZE(2, 2), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(12, 16), UPB_SIZE(3, 3), 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_DescriptorProto_ExtensionRange_msg_init = {
+ &google_protobuf_DescriptorProto_ExtensionRange_submsgs[0],
+ &google_protobuf_DescriptorProto_ExtensionRange__fields[0],
+ UPB_SIZE(16, 24), 3, kUpb_ExtMode_NonExtendable, 3, 255, 0,
+};
+
+static const upb_MiniTable_Field google_protobuf_DescriptorProto_ReservedRange__fields[2] = {
+ {1, UPB_SIZE(4, 4), UPB_SIZE(1, 1), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(8, 8), UPB_SIZE(2, 2), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_DescriptorProto_ReservedRange_msg_init = {
+ NULL,
+ &google_protobuf_DescriptorProto_ReservedRange__fields[0],
+ UPB_SIZE(16, 16), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_ExtensionRangeOptions_submsgs[1] = {
+ {.submsg = &google_protobuf_UninterpretedOption_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_ExtensionRangeOptions__fields[1] = {
+ {999, UPB_SIZE(0, 0), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_ExtensionRangeOptions_msg_init = {
+ &google_protobuf_ExtensionRangeOptions_submsgs[0],
+ &google_protobuf_ExtensionRangeOptions__fields[0],
+ UPB_SIZE(8, 8), 1, kUpb_ExtMode_Extendable, 0, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_FieldDescriptorProto_submsgs[3] = {
+ {.subenum = &google_protobuf_FieldDescriptorProto_Label_enum_init},
+ {.subenum = &google_protobuf_FieldDescriptorProto_Type_enum_init},
+ {.submsg = &google_protobuf_FieldOptions_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_FieldDescriptorProto__fields[11] = {
+ {1, UPB_SIZE(24, 24), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(32, 40), UPB_SIZE(2, 2), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(4, 4), UPB_SIZE(3, 3), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {4, UPB_SIZE(8, 8), UPB_SIZE(4, 4), 0, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {5, UPB_SIZE(12, 12), UPB_SIZE(5, 5), 1, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {6, UPB_SIZE(40, 56), UPB_SIZE(6, 6), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {7, UPB_SIZE(48, 72), UPB_SIZE(7, 7), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {8, UPB_SIZE(56, 88), UPB_SIZE(8, 8), 2, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {9, UPB_SIZE(16, 16), UPB_SIZE(9, 9), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {10, UPB_SIZE(60, 96), UPB_SIZE(10, 10), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {17, UPB_SIZE(20, 20), UPB_SIZE(11, 11), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_FieldDescriptorProto_msg_init = {
+ &google_protobuf_FieldDescriptorProto_submsgs[0],
+ &google_protobuf_FieldDescriptorProto__fields[0],
+ UPB_SIZE(72, 112), 11, kUpb_ExtMode_NonExtendable, 10, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_OneofDescriptorProto_submsgs[1] = {
+ {.submsg = &google_protobuf_OneofOptions_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_OneofDescriptorProto__fields[2] = {
+ {1, UPB_SIZE(4, 8), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(12, 24), UPB_SIZE(2, 2), 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_OneofDescriptorProto_msg_init = {
+ &google_protobuf_OneofDescriptorProto_submsgs[0],
+ &google_protobuf_OneofDescriptorProto__fields[0],
+ UPB_SIZE(16, 32), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_EnumDescriptorProto_submsgs[3] = {
+ {.submsg = &google_protobuf_EnumValueDescriptorProto_msg_init},
+ {.submsg = &google_protobuf_EnumOptions_msg_init},
+ {.submsg = &google_protobuf_EnumDescriptorProto_EnumReservedRange_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_EnumDescriptorProto__fields[5] = {
+ {1, UPB_SIZE(4, 8), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(12, 24), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(16, 32), UPB_SIZE(2, 2), 1, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {4, UPB_SIZE(20, 40), UPB_SIZE(0, 0), 2, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {5, UPB_SIZE(24, 48), UPB_SIZE(0, 0), kUpb_NoSub, 12, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_EnumDescriptorProto_msg_init = {
+ &google_protobuf_EnumDescriptorProto_submsgs[0],
+ &google_protobuf_EnumDescriptorProto__fields[0],
+ UPB_SIZE(32, 56), 5, kUpb_ExtMode_NonExtendable, 5, 255, 0,
+};
+
+static const upb_MiniTable_Field google_protobuf_EnumDescriptorProto_EnumReservedRange__fields[2] = {
+ {1, UPB_SIZE(4, 4), UPB_SIZE(1, 1), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(8, 8), UPB_SIZE(2, 2), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_EnumDescriptorProto_EnumReservedRange_msg_init = {
+ NULL,
+ &google_protobuf_EnumDescriptorProto_EnumReservedRange__fields[0],
+ UPB_SIZE(16, 16), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_EnumValueDescriptorProto_submsgs[1] = {
+ {.submsg = &google_protobuf_EnumValueOptions_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_EnumValueDescriptorProto__fields[3] = {
+ {1, UPB_SIZE(8, 8), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(4, 4), UPB_SIZE(2, 2), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(16, 24), UPB_SIZE(3, 3), 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_EnumValueDescriptorProto_msg_init = {
+ &google_protobuf_EnumValueDescriptorProto_submsgs[0],
+ &google_protobuf_EnumValueDescriptorProto__fields[0],
+ UPB_SIZE(24, 32), 3, kUpb_ExtMode_NonExtendable, 3, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_ServiceDescriptorProto_submsgs[2] = {
+ {.submsg = &google_protobuf_MethodDescriptorProto_msg_init},
+ {.submsg = &google_protobuf_ServiceOptions_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_ServiceDescriptorProto__fields[3] = {
+ {1, UPB_SIZE(4, 8), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(12, 24), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(16, 32), UPB_SIZE(2, 2), 1, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_ServiceDescriptorProto_msg_init = {
+ &google_protobuf_ServiceDescriptorProto_submsgs[0],
+ &google_protobuf_ServiceDescriptorProto__fields[0],
+ UPB_SIZE(24, 40), 3, kUpb_ExtMode_NonExtendable, 3, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_MethodDescriptorProto_submsgs[1] = {
+ {.submsg = &google_protobuf_MethodOptions_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_MethodDescriptorProto__fields[6] = {
+ {1, UPB_SIZE(4, 8), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(12, 24), UPB_SIZE(2, 2), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(20, 40), UPB_SIZE(3, 3), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {4, UPB_SIZE(28, 56), UPB_SIZE(4, 4), 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {5, UPB_SIZE(1, 1), UPB_SIZE(5, 5), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {6, UPB_SIZE(2, 2), UPB_SIZE(6, 6), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_MethodDescriptorProto_msg_init = {
+ &google_protobuf_MethodDescriptorProto_submsgs[0],
+ &google_protobuf_MethodDescriptorProto__fields[0],
+ UPB_SIZE(32, 64), 6, kUpb_ExtMode_NonExtendable, 6, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_FileOptions_submsgs[2] = {
+ {.subenum = &google_protobuf_FileOptions_OptimizeMode_enum_init},
+ {.submsg = &google_protobuf_UninterpretedOption_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_FileOptions__fields[21] = {
+ {1, UPB_SIZE(20, 24), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {8, UPB_SIZE(28, 40), UPB_SIZE(2, 2), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {9, UPB_SIZE(4, 4), UPB_SIZE(3, 3), 0, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {10, UPB_SIZE(8, 8), UPB_SIZE(4, 4), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {11, UPB_SIZE(36, 56), UPB_SIZE(5, 5), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {16, UPB_SIZE(9, 9), UPB_SIZE(6, 6), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {17, UPB_SIZE(10, 10), UPB_SIZE(7, 7), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {18, UPB_SIZE(11, 11), UPB_SIZE(8, 8), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {20, UPB_SIZE(12, 12), UPB_SIZE(9, 9), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {23, UPB_SIZE(13, 13), UPB_SIZE(10, 10), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {27, UPB_SIZE(14, 14), UPB_SIZE(11, 11), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {31, UPB_SIZE(15, 15), UPB_SIZE(12, 12), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {36, UPB_SIZE(44, 72), UPB_SIZE(13, 13), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {37, UPB_SIZE(52, 88), UPB_SIZE(14, 14), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {39, UPB_SIZE(60, 104), UPB_SIZE(15, 15), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {40, UPB_SIZE(68, 120), UPB_SIZE(16, 16), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {41, UPB_SIZE(76, 136), UPB_SIZE(17, 17), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {42, UPB_SIZE(16, 16), UPB_SIZE(18, 18), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {44, UPB_SIZE(84, 152), UPB_SIZE(19, 19), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {45, UPB_SIZE(92, 168), UPB_SIZE(20, 20), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {999, UPB_SIZE(100, 184), UPB_SIZE(0, 0), 1, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_FileOptions_msg_init = {
+ &google_protobuf_FileOptions_submsgs[0],
+ &google_protobuf_FileOptions__fields[0],
+ UPB_SIZE(104, 192), 21, kUpb_ExtMode_Extendable, 1, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_MessageOptions_submsgs[1] = {
+ {.submsg = &google_protobuf_UninterpretedOption_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_MessageOptions__fields[5] = {
+ {1, UPB_SIZE(1, 1), UPB_SIZE(1, 1), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(2, 2), UPB_SIZE(2, 2), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(3, 3), UPB_SIZE(3, 3), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {7, UPB_SIZE(4, 4), UPB_SIZE(4, 4), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {999, UPB_SIZE(8, 8), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_MessageOptions_msg_init = {
+ &google_protobuf_MessageOptions_submsgs[0],
+ &google_protobuf_MessageOptions__fields[0],
+ UPB_SIZE(16, 16), 5, kUpb_ExtMode_Extendable, 3, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_FieldOptions_submsgs[3] = {
+ {.subenum = &google_protobuf_FieldOptions_CType_enum_init},
+ {.subenum = &google_protobuf_FieldOptions_JSType_enum_init},
+ {.submsg = &google_protobuf_UninterpretedOption_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_FieldOptions__fields[8] = {
+ {1, UPB_SIZE(4, 4), UPB_SIZE(1, 1), 0, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(8, 8), UPB_SIZE(2, 2), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(9, 9), UPB_SIZE(3, 3), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {5, UPB_SIZE(10, 10), UPB_SIZE(4, 4), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {6, UPB_SIZE(12, 12), UPB_SIZE(5, 5), 1, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {10, UPB_SIZE(16, 16), UPB_SIZE(6, 6), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {15, UPB_SIZE(17, 17), UPB_SIZE(7, 7), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {999, UPB_SIZE(20, 24), UPB_SIZE(0, 0), 2, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_FieldOptions_msg_init = {
+ &google_protobuf_FieldOptions_submsgs[0],
+ &google_protobuf_FieldOptions__fields[0],
+ UPB_SIZE(24, 32), 8, kUpb_ExtMode_Extendable, 3, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_OneofOptions_submsgs[1] = {
+ {.submsg = &google_protobuf_UninterpretedOption_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_OneofOptions__fields[1] = {
+ {999, UPB_SIZE(0, 0), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_OneofOptions_msg_init = {
+ &google_protobuf_OneofOptions_submsgs[0],
+ &google_protobuf_OneofOptions__fields[0],
+ UPB_SIZE(8, 8), 1, kUpb_ExtMode_Extendable, 0, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_EnumOptions_submsgs[1] = {
+ {.submsg = &google_protobuf_UninterpretedOption_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_EnumOptions__fields[3] = {
+ {2, UPB_SIZE(1, 1), UPB_SIZE(1, 1), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(2, 2), UPB_SIZE(2, 2), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {999, UPB_SIZE(4, 8), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_EnumOptions_msg_init = {
+ &google_protobuf_EnumOptions_submsgs[0],
+ &google_protobuf_EnumOptions__fields[0],
+ UPB_SIZE(8, 16), 3, kUpb_ExtMode_Extendable, 0, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_EnumValueOptions_submsgs[1] = {
+ {.submsg = &google_protobuf_UninterpretedOption_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_EnumValueOptions__fields[2] = {
+ {1, UPB_SIZE(1, 1), UPB_SIZE(1, 1), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {999, UPB_SIZE(4, 8), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_EnumValueOptions_msg_init = {
+ &google_protobuf_EnumValueOptions_submsgs[0],
+ &google_protobuf_EnumValueOptions__fields[0],
+ UPB_SIZE(8, 16), 2, kUpb_ExtMode_Extendable, 1, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_ServiceOptions_submsgs[1] = {
+ {.submsg = &google_protobuf_UninterpretedOption_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_ServiceOptions__fields[2] = {
+ {33, UPB_SIZE(1, 1), UPB_SIZE(1, 1), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {999, UPB_SIZE(4, 8), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_ServiceOptions_msg_init = {
+ &google_protobuf_ServiceOptions_submsgs[0],
+ &google_protobuf_ServiceOptions__fields[0],
+ UPB_SIZE(8, 16), 2, kUpb_ExtMode_Extendable, 0, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_MethodOptions_submsgs[2] = {
+ {.subenum = &google_protobuf_MethodOptions_IdempotencyLevel_enum_init},
+ {.submsg = &google_protobuf_UninterpretedOption_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_MethodOptions__fields[3] = {
+ {33, UPB_SIZE(1, 1), UPB_SIZE(1, 1), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+ {34, UPB_SIZE(4, 4), UPB_SIZE(2, 2), 0, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {999, UPB_SIZE(8, 8), UPB_SIZE(0, 0), 1, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_MethodOptions_msg_init = {
+ &google_protobuf_MethodOptions_submsgs[0],
+ &google_protobuf_MethodOptions__fields[0],
+ UPB_SIZE(16, 16), 3, kUpb_ExtMode_Extendable, 0, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_UninterpretedOption_submsgs[1] = {
+ {.submsg = &google_protobuf_UninterpretedOption_NamePart_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_UninterpretedOption__fields[7] = {
+ {2, UPB_SIZE(4, 8), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(8, 16), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {4, UPB_SIZE(32, 64), UPB_SIZE(2, 2), kUpb_NoSub, 4, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+ {5, UPB_SIZE(40, 72), UPB_SIZE(3, 3), kUpb_NoSub, 3, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+ {6, UPB_SIZE(48, 80), UPB_SIZE(4, 4), kUpb_NoSub, 1, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+ {7, UPB_SIZE(16, 32), UPB_SIZE(5, 5), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {8, UPB_SIZE(24, 48), UPB_SIZE(6, 6), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_UninterpretedOption_msg_init = {
+ &google_protobuf_UninterpretedOption_submsgs[0],
+ &google_protobuf_UninterpretedOption__fields[0],
+ UPB_SIZE(56, 88), 7, kUpb_ExtMode_NonExtendable, 0, 255, 0,
+};
+
+static const upb_MiniTable_Field google_protobuf_UninterpretedOption_NamePart__fields[2] = {
+ {1, UPB_SIZE(4, 8), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(1, 1), UPB_SIZE(2, 2), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_UninterpretedOption_NamePart_msg_init = {
+ NULL,
+ &google_protobuf_UninterpretedOption_NamePart__fields[0],
+ UPB_SIZE(16, 24), 2, kUpb_ExtMode_NonExtendable, 2, 255, 2,
+};
+
+static const upb_MiniTable_Sub google_protobuf_SourceCodeInfo_submsgs[1] = {
+ {.submsg = &google_protobuf_SourceCodeInfo_Location_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_SourceCodeInfo__fields[1] = {
+ {1, UPB_SIZE(0, 0), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_SourceCodeInfo_msg_init = {
+ &google_protobuf_SourceCodeInfo_submsgs[0],
+ &google_protobuf_SourceCodeInfo__fields[0],
+ UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
+};
+
+static const upb_MiniTable_Field google_protobuf_SourceCodeInfo_Location__fields[5] = {
+ {1, UPB_SIZE(4, 8), UPB_SIZE(0, 0), kUpb_NoSub, 5, kUpb_FieldMode_Array | kUpb_LabelFlags_IsPacked | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(8, 16), UPB_SIZE(0, 0), kUpb_NoSub, 5, kUpb_FieldMode_Array | kUpb_LabelFlags_IsPacked | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(12, 24), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {4, UPB_SIZE(20, 40), UPB_SIZE(2, 2), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {6, UPB_SIZE(28, 56), UPB_SIZE(0, 0), kUpb_NoSub, 12, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_SourceCodeInfo_Location_msg_init = {
+ NULL,
+ &google_protobuf_SourceCodeInfo_Location__fields[0],
+ UPB_SIZE(32, 64), 5, kUpb_ExtMode_NonExtendable, 4, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_GeneratedCodeInfo_submsgs[1] = {
+ {.submsg = &google_protobuf_GeneratedCodeInfo_Annotation_msg_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_GeneratedCodeInfo__fields[1] = {
+ {1, UPB_SIZE(0, 0), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_GeneratedCodeInfo_msg_init = {
+ &google_protobuf_GeneratedCodeInfo_submsgs[0],
+ &google_protobuf_GeneratedCodeInfo__fields[0],
+ UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
+};
+
+static const upb_MiniTable_Sub google_protobuf_GeneratedCodeInfo_Annotation_submsgs[1] = {
+ {.subenum = &google_protobuf_GeneratedCodeInfo_Annotation_Semantic_enum_init},
+};
+
+static const upb_MiniTable_Field google_protobuf_GeneratedCodeInfo_Annotation__fields[5] = {
+ {1, UPB_SIZE(16, 16), UPB_SIZE(0, 0), kUpb_NoSub, 5, kUpb_FieldMode_Array | kUpb_LabelFlags_IsPacked | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+ {2, UPB_SIZE(20, 24), UPB_SIZE(1, 1), kUpb_NoSub, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+ {3, UPB_SIZE(4, 4), UPB_SIZE(2, 2), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {4, UPB_SIZE(8, 8), UPB_SIZE(3, 3), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+ {5, UPB_SIZE(12, 12), UPB_SIZE(4, 4), 0, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable google_protobuf_GeneratedCodeInfo_Annotation_msg_init = {
+ &google_protobuf_GeneratedCodeInfo_Annotation_submsgs[0],
+ &google_protobuf_GeneratedCodeInfo_Annotation__fields[0],
+ UPB_SIZE(32, 40), 5, kUpb_ExtMode_NonExtendable, 5, 255, 0,
+};
+
+static const upb_MiniTable *messages_layout[27] = {
+ &google_protobuf_FileDescriptorSet_msg_init,
+ &google_protobuf_FileDescriptorProto_msg_init,
+ &google_protobuf_DescriptorProto_msg_init,
+ &google_protobuf_DescriptorProto_ExtensionRange_msg_init,
+ &google_protobuf_DescriptorProto_ReservedRange_msg_init,
+ &google_protobuf_ExtensionRangeOptions_msg_init,
+ &google_protobuf_FieldDescriptorProto_msg_init,
+ &google_protobuf_OneofDescriptorProto_msg_init,
+ &google_protobuf_EnumDescriptorProto_msg_init,
+ &google_protobuf_EnumDescriptorProto_EnumReservedRange_msg_init,
+ &google_protobuf_EnumValueDescriptorProto_msg_init,
+ &google_protobuf_ServiceDescriptorProto_msg_init,
+ &google_protobuf_MethodDescriptorProto_msg_init,
+ &google_protobuf_FileOptions_msg_init,
+ &google_protobuf_MessageOptions_msg_init,
+ &google_protobuf_FieldOptions_msg_init,
+ &google_protobuf_OneofOptions_msg_init,
+ &google_protobuf_EnumOptions_msg_init,
+ &google_protobuf_EnumValueOptions_msg_init,
+ &google_protobuf_ServiceOptions_msg_init,
+ &google_protobuf_MethodOptions_msg_init,
+ &google_protobuf_UninterpretedOption_msg_init,
+ &google_protobuf_UninterpretedOption_NamePart_msg_init,
+ &google_protobuf_SourceCodeInfo_msg_init,
+ &google_protobuf_SourceCodeInfo_Location_msg_init,
+ &google_protobuf_GeneratedCodeInfo_msg_init,
+ &google_protobuf_GeneratedCodeInfo_Annotation_msg_init,
+};
+
+const upb_MiniTable_Enum google_protobuf_FieldDescriptorProto_Type_enum_init = {
+ 64,
+ 0,
+ {
+ 0x7fffe,
+ 0x0,
+ },
+};
+
+const upb_MiniTable_Enum google_protobuf_FieldDescriptorProto_Label_enum_init = {
+ 64,
+ 0,
+ {
+ 0xe,
+ 0x0,
+ },
+};
+
+const upb_MiniTable_Enum google_protobuf_FileOptions_OptimizeMode_enum_init = {
+ 64,
+ 0,
+ {
+ 0xe,
+ 0x0,
+ },
+};
+
+const upb_MiniTable_Enum google_protobuf_FieldOptions_CType_enum_init = {
+ 64,
+ 0,
+ {
+ 0x7,
+ 0x0,
+ },
+};
+
+const upb_MiniTable_Enum google_protobuf_FieldOptions_JSType_enum_init = {
+ 64,
+ 0,
+ {
+ 0x7,
+ 0x0,
+ },
+};
+
+const upb_MiniTable_Enum google_protobuf_MethodOptions_IdempotencyLevel_enum_init = {
+ 64,
+ 0,
+ {
+ 0x7,
+ 0x0,
+ },
+};
+
+const upb_MiniTable_Enum google_protobuf_GeneratedCodeInfo_Annotation_Semantic_enum_init = {
+ 64,
+ 0,
+ {
+ 0x7,
+ 0x0,
+ },
+};
+
+static const upb_MiniTable_Enum *enums_layout[7] = {
+ &google_protobuf_FieldDescriptorProto_Type_enum_init,
+ &google_protobuf_FieldDescriptorProto_Label_enum_init,
+ &google_protobuf_FileOptions_OptimizeMode_enum_init,
+ &google_protobuf_FieldOptions_CType_enum_init,
+ &google_protobuf_FieldOptions_JSType_enum_init,
+ &google_protobuf_MethodOptions_IdempotencyLevel_enum_init,
+ &google_protobuf_GeneratedCodeInfo_Annotation_Semantic_enum_init,
+};
+
+const upb_MiniTable_File google_protobuf_descriptor_proto_upb_file_layout = {
+ messages_layout,
+ enums_layout,
+ NULL,
+ 27,
+ 7,
+ 0,
+};
+
+
+
+
+
+// Must be last.
struct upb_ExtensionRegistry {
upb_Arena* arena;
@@ -2301,6 +1087,8 @@
const upb_MiniTable_Extension** start = e;
const upb_MiniTable_Extension** end = UPB_PTRADD(e, count);
for (; e < end; e++) {
+ // TODO: we should gracefully handle the case where this already exists.
+ // Right now we're only checking for out of memory.
const upb_MiniTable_Extension* ext = *e;
extreg_key(buf, ext->extendee, ext->field.number);
if (!upb_strtable_insert(&r->exts, buf, EXTREG_KEY_SIZE,
@@ -2333,17 +1121,8031 @@
}
}
-/** upb/table.c ************************************************************/
+// Fast decoder: ~3x the speed of decode.c, but requires x86-64/ARM64.
+// Also the table size grows by 2x.
+//
+// Could potentially be ported to other 64-bit archs that pass at least six
+// arguments in registers and have 8 unused high bits in pointers.
+//
+// The overall design is to create specialized functions for every possible
+// field type (eg. oneof boolean field with a 1 byte tag) and then dispatch
+// to the specialized function as quickly as possible.
+
+
+
+// Must be last.
+
+#if UPB_FASTTABLE
+
+// The standard set of arguments passed to each parsing function.
+// Thanks to x86-64 calling conventions, these will stay in registers.
+#define UPB_PARSE_PARAMS \
+ upb_Decoder *d, const char *ptr, upb_Message *msg, intptr_t table, \
+ uint64_t hasbits, uint64_t data
+
+#define UPB_PARSE_ARGS d, ptr, msg, table, hasbits, data
+
+#define RETURN_GENERIC(m) \
+ /* Uncomment either of these for debugging purposes. */ \
+ /* fprintf(stderr, m); */ \
+ /*__builtin_trap(); */ \
+ return _upb_FastDecoder_DecodeGeneric(d, ptr, msg, table, hasbits, 0);
+
+typedef enum {
+ CARD_s = 0, /* Singular (optional, non-repeated) */
+ CARD_o = 1, /* Oneof */
+ CARD_r = 2, /* Repeated */
+ CARD_p = 3 /* Packed Repeated */
+} upb_card;
+
+UPB_NOINLINE
+static const char* fastdecode_isdonefallback(UPB_PARSE_PARAMS) {
+ int overrun = data;
+ int status;
+ ptr = _upb_Decoder_IsDoneFallbackInline(d, ptr, overrun, &status);
+ if (ptr == NULL) _upb_FastDecoder_ErrorJmp(d, status);
+ data = _upb_FastDecoder_LoadTag(ptr);
+ UPB_MUSTTAIL return _upb_FastDecoder_TagDispatch(UPB_PARSE_ARGS);
+}
+
+UPB_FORCEINLINE
+static const char* fastdecode_dispatch(UPB_PARSE_PARAMS) {
+ if (UPB_UNLIKELY(ptr >= d->limit_ptr)) {
+ int overrun = ptr - d->end;
+ if (UPB_LIKELY(overrun == d->limit)) {
+ // Parse is finished.
+ *(uint32_t*)msg |= hasbits; // Sync hasbits.
+ const upb_MiniTable* l = decode_totablep(table);
+ return UPB_UNLIKELY(l->required_count)
+ ? _upb_Decoder_CheckRequired(d, ptr, msg, l)
+ : ptr;
+ } else {
+ data = overrun;
+ UPB_MUSTTAIL return fastdecode_isdonefallback(UPB_PARSE_ARGS);
+ }
+ }
+
+ // Read two bytes of tag data (for a one-byte tag, the high byte is junk).
+ data = _upb_FastDecoder_LoadTag(ptr);
+ UPB_MUSTTAIL return _upb_FastDecoder_TagDispatch(UPB_PARSE_ARGS);
+}
+
+UPB_FORCEINLINE
+static bool fastdecode_checktag(uint16_t data, int tagbytes) {
+ if (tagbytes == 1) {
+ return (data & 0xff) == 0;
+ } else {
+ return data == 0;
+ }
+}
+
+UPB_FORCEINLINE
+static const char* fastdecode_longsize(const char* ptr, int* size) {
+ int i;
+ UPB_ASSERT(*size & 0x80);
+ *size &= 0xff;
+ for (i = 0; i < 3; i++) {
+ ptr++;
+ size_t byte = (uint8_t)ptr[-1];
+ *size += (byte - 1) << (7 + 7 * i);
+ if (UPB_LIKELY((byte & 0x80) == 0)) return ptr;
+ }
+ ptr++;
+ size_t byte = (uint8_t)ptr[-1];
+ // len is limited by 2gb not 4gb, hence 8 and not 16 as normally expected
+ // for a 32 bit varint.
+ if (UPB_UNLIKELY(byte >= 8)) return NULL;
+ *size += (byte - 1) << 28;
+ return ptr;
+}
+
+UPB_FORCEINLINE
+static bool fastdecode_boundscheck(const char* ptr, size_t len,
+ const char* end) {
+ uintptr_t uptr = (uintptr_t)ptr;
+ uintptr_t uend = (uintptr_t)end + 16;
+ uintptr_t res = uptr + len;
+ return res < uptr || res > uend;
+}
+
+UPB_FORCEINLINE
+static bool fastdecode_boundscheck2(const char* ptr, size_t len,
+ const char* end) {
+ // This is one extra branch compared to the more normal:
+ // return (size_t)(end - ptr) < size;
+ // However it is one less computation if we are just about to use "ptr + len":
+ // https://godbolt.org/z/35YGPz
+ // In microbenchmarks this shows an overall 4% improvement.
+ uintptr_t uptr = (uintptr_t)ptr;
+ uintptr_t uend = (uintptr_t)end;
+ uintptr_t res = uptr + len;
+ return res < uptr || res > uend;
+}
+
+typedef const char* fastdecode_delimfunc(upb_Decoder* d, const char* ptr,
+ void* ctx);
+
+UPB_FORCEINLINE
+static const char* fastdecode_delimited(upb_Decoder* d, const char* ptr,
+ fastdecode_delimfunc* func, void* ctx) {
+ ptr++;
+ int len = (int8_t)ptr[-1];
+ if (fastdecode_boundscheck2(ptr, len, d->limit_ptr)) {
+ // Slow case: Sub-message is >=128 bytes and/or exceeds the current buffer.
+ // If it exceeds the buffer limit, limit/limit_ptr will change during
+ // sub-message parsing, so we need to preserve delta, not limit.
+ if (UPB_UNLIKELY(len & 0x80)) {
+ // Size varint >1 byte (length >= 128).
+ ptr = fastdecode_longsize(ptr, &len);
+ if (!ptr) {
+ // Corrupt wire format: size exceeded INT_MAX.
+ return NULL;
+ }
+ }
+ if (ptr - d->end + (int)len > d->limit) {
+ // Corrupt wire format: invalid limit.
+ return NULL;
+ }
+ int delta = _upb_Decoder_PushLimit(d, ptr, len);
+ ptr = func(d, ptr, ctx);
+ _upb_Decoder_PopLimit(d, ptr, delta);
+ } else {
+ // Fast case: Sub-message is <128 bytes and fits in the current buffer.
+ // This means we can preserve limit/limit_ptr verbatim.
+ const char* saved_limit_ptr = d->limit_ptr;
+ int saved_limit = d->limit;
+ d->limit_ptr = ptr + len;
+ d->limit = d->limit_ptr - d->end;
+ UPB_ASSERT(d->limit_ptr == d->end + UPB_MIN(0, d->limit));
+ ptr = func(d, ptr, ctx);
+ d->limit_ptr = saved_limit_ptr;
+ d->limit = saved_limit;
+ UPB_ASSERT(d->limit_ptr == d->end + UPB_MIN(0, d->limit));
+ }
+ return ptr;
+}
+
+/* singular, oneof, repeated field handling ***********************************/
+
+typedef struct {
+ upb_Array* arr;
+ void* end;
+} fastdecode_arr;
+
+typedef enum {
+ FD_NEXT_ATLIMIT,
+ FD_NEXT_SAMEFIELD,
+ FD_NEXT_OTHERFIELD
+} fastdecode_next;
+
+typedef struct {
+ void* dst;
+ fastdecode_next next;
+ uint32_t tag;
+} fastdecode_nextret;
+
+UPB_FORCEINLINE
+static void* fastdecode_resizearr(upb_Decoder* d, void* dst,
+ fastdecode_arr* farr, int valbytes) {
+ if (UPB_UNLIKELY(dst == farr->end)) {
+ size_t old_size = farr->arr->capacity;
+ size_t old_bytes = old_size * valbytes;
+ size_t new_size = old_size * 2;
+ size_t new_bytes = new_size * valbytes;
+ char* old_ptr = _upb_array_ptr(farr->arr);
+ char* new_ptr = upb_Arena_Realloc(&d->arena, old_ptr, old_bytes, new_bytes);
+ uint8_t elem_size_lg2 = __builtin_ctz(valbytes);
+ farr->arr->capacity = new_size;
+ farr->arr->data = _upb_array_tagptr(new_ptr, elem_size_lg2);
+ dst = (void*)(new_ptr + (old_size * valbytes));
+ farr->end = (void*)(new_ptr + (new_size * valbytes));
+ }
+ return dst;
+}
+
+UPB_FORCEINLINE
+static bool fastdecode_tagmatch(uint32_t tag, uint64_t data, int tagbytes) {
+ if (tagbytes == 1) {
+ return (uint8_t)tag == (uint8_t)data;
+ } else {
+ return (uint16_t)tag == (uint16_t)data;
+ }
+}
+
+UPB_FORCEINLINE
+static void fastdecode_commitarr(void* dst, fastdecode_arr* farr,
+ int valbytes) {
+ farr->arr->size =
+ (size_t)((char*)dst - (char*)_upb_array_ptr(farr->arr)) / valbytes;
+}
+
+UPB_FORCEINLINE
+static fastdecode_nextret fastdecode_nextrepeated(upb_Decoder* d, void* dst,
+ const char** ptr,
+ fastdecode_arr* farr,
+ uint64_t data, int tagbytes,
+ int valbytes) {
+ fastdecode_nextret ret;
+ dst = (char*)dst + valbytes;
+
+ if (UPB_LIKELY(!_upb_Decoder_IsDone(d, ptr))) {
+ ret.tag = _upb_FastDecoder_LoadTag(*ptr);
+ if (fastdecode_tagmatch(ret.tag, data, tagbytes)) {
+ ret.next = FD_NEXT_SAMEFIELD;
+ } else {
+ fastdecode_commitarr(dst, farr, valbytes);
+ ret.next = FD_NEXT_OTHERFIELD;
+ }
+ } else {
+ fastdecode_commitarr(dst, farr, valbytes);
+ ret.next = FD_NEXT_ATLIMIT;
+ }
+
+ ret.dst = dst;
+ return ret;
+}
+
+UPB_FORCEINLINE
+static void* fastdecode_fieldmem(upb_Message* msg, uint64_t data) {
+ size_t ofs = data >> 48;
+ return (char*)msg + ofs;
+}
+
+UPB_FORCEINLINE
+static void* fastdecode_getfield(upb_Decoder* d, const char* ptr,
+ upb_Message* msg, uint64_t* data,
+ uint64_t* hasbits, fastdecode_arr* farr,
+ int valbytes, upb_card card) {
+ switch (card) {
+ case CARD_s: {
+ uint8_t hasbit_index = *data >> 24;
+ // Set hasbit and return pointer to scalar field.
+ *hasbits |= 1ull << hasbit_index;
+ return fastdecode_fieldmem(msg, *data);
+ }
+ case CARD_o: {
+ uint16_t case_ofs = *data >> 32;
+ uint32_t* oneof_case = UPB_PTR_AT(msg, case_ofs, uint32_t);
+ uint8_t field_number = *data >> 24;
+ *oneof_case = field_number;
+ return fastdecode_fieldmem(msg, *data);
+ }
+ case CARD_r: {
+ // Get pointer to upb_Array and allocate/expand if necessary.
+ uint8_t elem_size_lg2 = __builtin_ctz(valbytes);
+ upb_Array** arr_p = fastdecode_fieldmem(msg, *data);
+ char* begin;
+ *(uint32_t*)msg |= *hasbits;
+ *hasbits = 0;
+ if (UPB_LIKELY(!*arr_p)) {
+ farr->arr = _upb_Array_New(&d->arena, 8, elem_size_lg2);
+ *arr_p = farr->arr;
+ } else {
+ farr->arr = *arr_p;
+ }
+ begin = _upb_array_ptr(farr->arr);
+ farr->end = begin + (farr->arr->capacity * valbytes);
+ *data = _upb_FastDecoder_LoadTag(ptr);
+ return begin + (farr->arr->size * valbytes);
+ }
+ default:
+ UPB_UNREACHABLE();
+ }
+}
+
+UPB_FORCEINLINE
+static bool fastdecode_flippacked(uint64_t* data, int tagbytes) {
+ *data ^= (0x2 ^ 0x0); // Patch data to match packed wiretype.
+ return fastdecode_checktag(*data, tagbytes);
+}
+
+#define FASTDECODE_CHECKPACKED(tagbytes, card, func) \
+ if (UPB_UNLIKELY(!fastdecode_checktag(data, tagbytes))) { \
+ if (card == CARD_r && fastdecode_flippacked(&data, tagbytes)) { \
+ UPB_MUSTTAIL return func(UPB_PARSE_ARGS); \
+ } \
+ RETURN_GENERIC("packed check tag mismatch\n"); \
+ }
+
+/* varint fields **************************************************************/
+
+UPB_FORCEINLINE
+static uint64_t fastdecode_munge(uint64_t val, int valbytes, bool zigzag) {
+ if (valbytes == 1) {
+ return val != 0;
+ } else if (zigzag) {
+ if (valbytes == 4) {
+ uint32_t n = val;
+ return (n >> 1) ^ -(int32_t)(n & 1);
+ } else if (valbytes == 8) {
+ return (val >> 1) ^ -(int64_t)(val & 1);
+ }
+ UPB_UNREACHABLE();
+ }
+ return val;
+}
+
+UPB_FORCEINLINE
+static const char* fastdecode_varint64(const char* ptr, uint64_t* val) {
+ ptr++;
+ *val = (uint8_t)ptr[-1];
+ if (UPB_UNLIKELY(*val & 0x80)) {
+ int i;
+ for (i = 0; i < 8; i++) {
+ ptr++;
+ uint64_t byte = (uint8_t)ptr[-1];
+ *val += (byte - 1) << (7 + 7 * i);
+ if (UPB_LIKELY((byte & 0x80) == 0)) goto done;
+ }
+ ptr++;
+ uint64_t byte = (uint8_t)ptr[-1];
+ if (byte > 1) {
+ return NULL;
+ }
+ *val += (byte - 1) << 63;
+ }
+done:
+ UPB_ASSUME(ptr != NULL);
+ return ptr;
+}
+
+#define FASTDECODE_UNPACKEDVARINT(d, ptr, msg, table, hasbits, data, tagbytes, \
+ valbytes, card, zigzag, packed) \
+ uint64_t val; \
+ void* dst; \
+ fastdecode_arr farr; \
+ \
+ FASTDECODE_CHECKPACKED(tagbytes, card, packed); \
+ \
+ dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &farr, valbytes, \
+ card); \
+ if (card == CARD_r) { \
+ if (UPB_UNLIKELY(!dst)) { \
+ RETURN_GENERIC("need array resize\n"); \
+ } \
+ } \
+ \
+ again: \
+ if (card == CARD_r) { \
+ dst = fastdecode_resizearr(d, dst, &farr, valbytes); \
+ } \
+ \
+ ptr += tagbytes; \
+ ptr = fastdecode_varint64(ptr, &val); \
+ if (ptr == NULL) _upb_FastDecoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed); \
+ val = fastdecode_munge(val, valbytes, zigzag); \
+ memcpy(dst, &val, valbytes); \
+ \
+ if (card == CARD_r) { \
+ fastdecode_nextret ret = fastdecode_nextrepeated( \
+ d, dst, &ptr, &farr, data, tagbytes, valbytes); \
+ switch (ret.next) { \
+ case FD_NEXT_SAMEFIELD: \
+ dst = ret.dst; \
+ goto again; \
+ case FD_NEXT_OTHERFIELD: \
+ data = ret.tag; \
+ UPB_MUSTTAIL return _upb_FastDecoder_TagDispatch(UPB_PARSE_ARGS); \
+ case FD_NEXT_ATLIMIT: \
+ return ptr; \
+ } \
+ } \
+ \
+ UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
+
+typedef struct {
+ uint8_t valbytes;
+ bool zigzag;
+ void* dst;
+ fastdecode_arr farr;
+} fastdecode_varintdata;
+
+UPB_FORCEINLINE
+static const char* fastdecode_topackedvarint(upb_Decoder* d, const char* ptr,
+ void* ctx) {
+ fastdecode_varintdata* data = ctx;
+ void* dst = data->dst;
+ uint64_t val;
+
+ while (!_upb_Decoder_IsDone(d, &ptr)) {
+ dst = fastdecode_resizearr(d, dst, &data->farr, data->valbytes);
+ ptr = fastdecode_varint64(ptr, &val);
+ if (ptr == NULL) return NULL;
+ val = fastdecode_munge(val, data->valbytes, data->zigzag);
+ memcpy(dst, &val, data->valbytes);
+ dst = (char*)dst + data->valbytes;
+ }
+
+ fastdecode_commitarr(dst, &data->farr, data->valbytes);
+ return ptr;
+}
+
+#define FASTDECODE_PACKEDVARINT(d, ptr, msg, table, hasbits, data, tagbytes, \
+ valbytes, zigzag, unpacked) \
+ fastdecode_varintdata ctx = {valbytes, zigzag}; \
+ \
+ FASTDECODE_CHECKPACKED(tagbytes, CARD_r, unpacked); \
+ \
+ ctx.dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &ctx.farr, \
+ valbytes, CARD_r); \
+ if (UPB_UNLIKELY(!ctx.dst)) { \
+ RETURN_GENERIC("need array resize\n"); \
+ } \
+ \
+ ptr += tagbytes; \
+ ptr = fastdecode_delimited(d, ptr, &fastdecode_topackedvarint, &ctx); \
+ \
+ if (UPB_UNLIKELY(ptr == NULL)) { \
+ _upb_FastDecoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed); \
+ } \
+ \
+ UPB_MUSTTAIL return fastdecode_dispatch(d, ptr, msg, table, hasbits, 0);
+
+#define FASTDECODE_VARINT(d, ptr, msg, table, hasbits, data, tagbytes, \
+ valbytes, card, zigzag, unpacked, packed) \
+ if (card == CARD_p) { \
+ FASTDECODE_PACKEDVARINT(d, ptr, msg, table, hasbits, data, tagbytes, \
+ valbytes, zigzag, unpacked); \
+ } else { \
+ FASTDECODE_UNPACKEDVARINT(d, ptr, msg, table, hasbits, data, tagbytes, \
+ valbytes, card, zigzag, packed); \
+ }
+
+#define z_ZZ true
+#define b_ZZ false
+#define v_ZZ false
+
+/* Generate all combinations:
+ * {s,o,r,p} x {b1,v4,z4,v8,z8} x {1bt,2bt} */
+
+#define F(card, type, valbytes, tagbytes) \
+ UPB_NOINLINE \
+ const char* upb_p##card##type##valbytes##_##tagbytes##bt(UPB_PARSE_PARAMS) { \
+ FASTDECODE_VARINT(d, ptr, msg, table, hasbits, data, tagbytes, valbytes, \
+ CARD_##card, type##_ZZ, \
+ upb_pr##type##valbytes##_##tagbytes##bt, \
+ upb_pp##type##valbytes##_##tagbytes##bt); \
+ }
+
+#define TYPES(card, tagbytes) \
+ F(card, b, 1, tagbytes) \
+ F(card, v, 4, tagbytes) \
+ F(card, v, 8, tagbytes) \
+ F(card, z, 4, tagbytes) \
+ F(card, z, 8, tagbytes)
+
+#define TAGBYTES(card) \
+ TYPES(card, 1) \
+ TYPES(card, 2)
+
+TAGBYTES(s)
+TAGBYTES(o)
+TAGBYTES(r)
+TAGBYTES(p)
+
+#undef z_ZZ
+#undef b_ZZ
+#undef v_ZZ
+#undef o_ONEOF
+#undef s_ONEOF
+#undef r_ONEOF
+#undef F
+#undef TYPES
+#undef TAGBYTES
+#undef FASTDECODE_UNPACKEDVARINT
+#undef FASTDECODE_PACKEDVARINT
+#undef FASTDECODE_VARINT
+
+/* fixed fields ***************************************************************/
+
+#define FASTDECODE_UNPACKEDFIXED(d, ptr, msg, table, hasbits, data, tagbytes, \
+ valbytes, card, packed) \
+ void* dst; \
+ fastdecode_arr farr; \
+ \
+ FASTDECODE_CHECKPACKED(tagbytes, card, packed) \
+ \
+ dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &farr, valbytes, \
+ card); \
+ if (card == CARD_r) { \
+ if (UPB_UNLIKELY(!dst)) { \
+ RETURN_GENERIC("couldn't allocate array in arena\n"); \
+ } \
+ } \
+ \
+ again: \
+ if (card == CARD_r) { \
+ dst = fastdecode_resizearr(d, dst, &farr, valbytes); \
+ } \
+ \
+ ptr += tagbytes; \
+ memcpy(dst, ptr, valbytes); \
+ ptr += valbytes; \
+ \
+ if (card == CARD_r) { \
+ fastdecode_nextret ret = fastdecode_nextrepeated( \
+ d, dst, &ptr, &farr, data, tagbytes, valbytes); \
+ switch (ret.next) { \
+ case FD_NEXT_SAMEFIELD: \
+ dst = ret.dst; \
+ goto again; \
+ case FD_NEXT_OTHERFIELD: \
+ data = ret.tag; \
+ UPB_MUSTTAIL return _upb_FastDecoder_TagDispatch(UPB_PARSE_ARGS); \
+ case FD_NEXT_ATLIMIT: \
+ return ptr; \
+ } \
+ } \
+ \
+ UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
+
+#define FASTDECODE_PACKEDFIXED(d, ptr, msg, table, hasbits, data, tagbytes, \
+ valbytes, unpacked) \
+ FASTDECODE_CHECKPACKED(tagbytes, CARD_r, unpacked) \
+ \
+ ptr += tagbytes; \
+ int size = (uint8_t)ptr[0]; \
+ ptr++; \
+ if (size & 0x80) { \
+ ptr = fastdecode_longsize(ptr, &size); \
+ } \
+ \
+ if (UPB_UNLIKELY(fastdecode_boundscheck(ptr, size, d->limit_ptr) || \
+ (size % valbytes) != 0)) { \
+ _upb_FastDecoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed); \
+ } \
+ \
+ upb_Array** arr_p = fastdecode_fieldmem(msg, data); \
+ upb_Array* arr = *arr_p; \
+ uint8_t elem_size_lg2 = __builtin_ctz(valbytes); \
+ int elems = size / valbytes; \
+ \
+ if (UPB_LIKELY(!arr)) { \
+ *arr_p = arr = _upb_Array_New(&d->arena, elems, elem_size_lg2); \
+ if (!arr) { \
+ _upb_FastDecoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed); \
+ } \
+ } else { \
+ _upb_Array_Resize(arr, elems, &d->arena); \
+ } \
+ \
+ char* dst = _upb_array_ptr(arr); \
+ memcpy(dst, ptr, size); \
+ arr->size = elems; \
+ \
+ ptr += size; \
+ UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
+
+#define FASTDECODE_FIXED(d, ptr, msg, table, hasbits, data, tagbytes, \
+ valbytes, card, unpacked, packed) \
+ if (card == CARD_p) { \
+ FASTDECODE_PACKEDFIXED(d, ptr, msg, table, hasbits, data, tagbytes, \
+ valbytes, unpacked); \
+ } else { \
+ FASTDECODE_UNPACKEDFIXED(d, ptr, msg, table, hasbits, data, tagbytes, \
+ valbytes, card, packed); \
+ }
+
+/* Generate all combinations:
+ * {s,o,r,p} x {f4,f8} x {1bt,2bt} */
+
+#define F(card, valbytes, tagbytes) \
+ UPB_NOINLINE \
+ const char* upb_p##card##f##valbytes##_##tagbytes##bt(UPB_PARSE_PARAMS) { \
+ FASTDECODE_FIXED(d, ptr, msg, table, hasbits, data, tagbytes, valbytes, \
+ CARD_##card, upb_ppf##valbytes##_##tagbytes##bt, \
+ upb_prf##valbytes##_##tagbytes##bt); \
+ }
+
+#define TYPES(card, tagbytes) \
+ F(card, 4, tagbytes) \
+ F(card, 8, tagbytes)
+
+#define TAGBYTES(card) \
+ TYPES(card, 1) \
+ TYPES(card, 2)
+
+TAGBYTES(s)
+TAGBYTES(o)
+TAGBYTES(r)
+TAGBYTES(p)
+
+#undef F
+#undef TYPES
+#undef TAGBYTES
+#undef FASTDECODE_UNPACKEDFIXED
+#undef FASTDECODE_PACKEDFIXED
+
+/* string fields **************************************************************/
+
+typedef const char* fastdecode_copystr_func(struct upb_Decoder* d,
+ const char* ptr, upb_Message* msg,
+ const upb_MiniTable* table,
+ uint64_t hasbits,
+ upb_StringView* dst);
+
+UPB_NOINLINE
+static const char* fastdecode_verifyutf8(upb_Decoder* d, const char* ptr,
+ upb_Message* msg, intptr_t table,
+ uint64_t hasbits, uint64_t data) {
+ upb_StringView* dst = (upb_StringView*)data;
+ if (!_upb_Decoder_VerifyUtf8Inline(dst->data, dst->size)) {
+ _upb_FastDecoder_ErrorJmp(d, kUpb_DecodeStatus_BadUtf8);
+ }
+ UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
+}
+
+#define FASTDECODE_LONGSTRING(d, ptr, msg, table, hasbits, dst, validate_utf8) \
+ int size = (uint8_t)ptr[0]; /* Could plumb through hasbits. */ \
+ ptr++; \
+ if (size & 0x80) { \
+ ptr = fastdecode_longsize(ptr, &size); \
+ } \
+ \
+ if (UPB_UNLIKELY(fastdecode_boundscheck(ptr, size, d->limit_ptr))) { \
+ dst->size = 0; \
+ _upb_FastDecoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed); \
+ } \
+ \
+ if (d->options & kUpb_DecodeOption_AliasString) { \
+ dst->data = ptr; \
+ dst->size = size; \
+ } else { \
+ char* data = upb_Arena_Malloc(&d->arena, size); \
+ if (!data) { \
+ _upb_FastDecoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory); \
+ } \
+ memcpy(data, ptr, size); \
+ dst->data = data; \
+ dst->size = size; \
+ } \
+ \
+ ptr += size; \
+ if (validate_utf8) { \
+ data = (uint64_t)dst; \
+ UPB_MUSTTAIL return fastdecode_verifyutf8(UPB_PARSE_ARGS); \
+ } else { \
+ UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS); \
+ }
+
+UPB_NOINLINE
+static const char* fastdecode_longstring_utf8(struct upb_Decoder* d,
+ const char* ptr, upb_Message* msg,
+ intptr_t table, uint64_t hasbits,
+ uint64_t data) {
+ upb_StringView* dst = (upb_StringView*)data;
+ FASTDECODE_LONGSTRING(d, ptr, msg, table, hasbits, dst, true);
+}
+
+UPB_NOINLINE
+static const char* fastdecode_longstring_noutf8(
+ struct upb_Decoder* d, const char* ptr, upb_Message* msg, intptr_t table,
+ uint64_t hasbits, uint64_t data) {
+ upb_StringView* dst = (upb_StringView*)data;
+ FASTDECODE_LONGSTRING(d, ptr, msg, table, hasbits, dst, false);
+}
+
+UPB_FORCEINLINE
+static void fastdecode_docopy(upb_Decoder* d, const char* ptr, uint32_t size,
+ int copy, char* data, upb_StringView* dst) {
+ d->arena.head.ptr += copy;
+ dst->data = data;
+ UPB_UNPOISON_MEMORY_REGION(data, copy);
+ memcpy(data, ptr, copy);
+ UPB_POISON_MEMORY_REGION(data + size, copy - size);
+}
+
+#define FASTDECODE_COPYSTRING(d, ptr, msg, table, hasbits, data, tagbytes, \
+ card, validate_utf8) \
+ upb_StringView* dst; \
+ fastdecode_arr farr; \
+ int64_t size; \
+ size_t arena_has; \
+ size_t common_has; \
+ char* buf; \
+ \
+ UPB_ASSERT((d->options & kUpb_DecodeOption_AliasString) == 0); \
+ UPB_ASSERT(fastdecode_checktag(data, tagbytes)); \
+ \
+ dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &farr, \
+ sizeof(upb_StringView), card); \
+ \
+ again: \
+ if (card == CARD_r) { \
+ dst = fastdecode_resizearr(d, dst, &farr, sizeof(upb_StringView)); \
+ } \
+ \
+ size = (uint8_t)ptr[tagbytes]; \
+ ptr += tagbytes + 1; \
+ dst->size = size; \
+ \
+ buf = d->arena.head.ptr; \
+ arena_has = _upb_ArenaHas(&d->arena); \
+ common_has = UPB_MIN(arena_has, (d->end - ptr) + 16); \
+ \
+ if (UPB_LIKELY(size <= 15 - tagbytes)) { \
+ if (arena_has < 16) goto longstr; \
+ d->arena.head.ptr += 16; \
+ memcpy(buf, ptr - tagbytes - 1, 16); \
+ dst->data = buf + tagbytes + 1; \
+ } else if (UPB_LIKELY(size <= 32)) { \
+ if (UPB_UNLIKELY(common_has < 32)) goto longstr; \
+ fastdecode_docopy(d, ptr, size, 32, buf, dst); \
+ } else if (UPB_LIKELY(size <= 64)) { \
+ if (UPB_UNLIKELY(common_has < 64)) goto longstr; \
+ fastdecode_docopy(d, ptr, size, 64, buf, dst); \
+ } else if (UPB_LIKELY(size < 128)) { \
+ if (UPB_UNLIKELY(common_has < 128)) goto longstr; \
+ fastdecode_docopy(d, ptr, size, 128, buf, dst); \
+ } else { \
+ goto longstr; \
+ } \
+ \
+ ptr += size; \
+ \
+ if (card == CARD_r) { \
+ if (validate_utf8 && \
+ !_upb_Decoder_VerifyUtf8Inline(dst->data, dst->size)) { \
+ _upb_FastDecoder_ErrorJmp(d, kUpb_DecodeStatus_BadUtf8); \
+ } \
+ fastdecode_nextret ret = fastdecode_nextrepeated( \
+ d, dst, &ptr, &farr, data, tagbytes, sizeof(upb_StringView)); \
+ switch (ret.next) { \
+ case FD_NEXT_SAMEFIELD: \
+ dst = ret.dst; \
+ goto again; \
+ case FD_NEXT_OTHERFIELD: \
+ data = ret.tag; \
+ UPB_MUSTTAIL return _upb_FastDecoder_TagDispatch(UPB_PARSE_ARGS); \
+ case FD_NEXT_ATLIMIT: \
+ return ptr; \
+ } \
+ } \
+ \
+ if (card != CARD_r && validate_utf8) { \
+ data = (uint64_t)dst; \
+ UPB_MUSTTAIL return fastdecode_verifyutf8(UPB_PARSE_ARGS); \
+ } \
+ \
+ UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS); \
+ \
+ longstr: \
+ if (card == CARD_r) { \
+ fastdecode_commitarr(dst + 1, &farr, sizeof(upb_StringView)); \
+ } \
+ ptr--; \
+ if (validate_utf8) { \
+ UPB_MUSTTAIL return fastdecode_longstring_utf8(d, ptr, msg, table, \
+ hasbits, (uint64_t)dst); \
+ } else { \
+ UPB_MUSTTAIL return fastdecode_longstring_noutf8(d, ptr, msg, table, \
+ hasbits, (uint64_t)dst); \
+ }
+
+#define FASTDECODE_STRING(d, ptr, msg, table, hasbits, data, tagbytes, card, \
+ copyfunc, validate_utf8) \
+ upb_StringView* dst; \
+ fastdecode_arr farr; \
+ int64_t size; \
+ \
+ if (UPB_UNLIKELY(!fastdecode_checktag(data, tagbytes))) { \
+ RETURN_GENERIC("string field tag mismatch\n"); \
+ } \
+ \
+ if (UPB_UNLIKELY((d->options & kUpb_DecodeOption_AliasString) == 0)) { \
+ UPB_MUSTTAIL return copyfunc(UPB_PARSE_ARGS); \
+ } \
+ \
+ dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &farr, \
+ sizeof(upb_StringView), card); \
+ \
+ again: \
+ if (card == CARD_r) { \
+ dst = fastdecode_resizearr(d, dst, &farr, sizeof(upb_StringView)); \
+ } \
+ \
+ size = (int8_t)ptr[tagbytes]; \
+ ptr += tagbytes + 1; \
+ dst->data = ptr; \
+ dst->size = size; \
+ \
+ if (UPB_UNLIKELY(fastdecode_boundscheck(ptr, size, d->end))) { \
+ ptr--; \
+ if (validate_utf8) { \
+ return fastdecode_longstring_utf8(d, ptr, msg, table, hasbits, \
+ (uint64_t)dst); \
+ } else { \
+ return fastdecode_longstring_noutf8(d, ptr, msg, table, hasbits, \
+ (uint64_t)dst); \
+ } \
+ } \
+ \
+ ptr += size; \
+ \
+ if (card == CARD_r) { \
+ if (validate_utf8 && \
+ !_upb_Decoder_VerifyUtf8Inline(dst->data, dst->size)) { \
+ _upb_FastDecoder_ErrorJmp(d, kUpb_DecodeStatus_BadUtf8); \
+ } \
+ fastdecode_nextret ret = fastdecode_nextrepeated( \
+ d, dst, &ptr, &farr, data, tagbytes, sizeof(upb_StringView)); \
+ switch (ret.next) { \
+ case FD_NEXT_SAMEFIELD: \
+ dst = ret.dst; \
+ if (UPB_UNLIKELY((d->options & kUpb_DecodeOption_AliasString) == 0)) { \
+ /* Buffer flipped and we can't alias any more. Bounce to */ \
+ /* copyfunc(), but via dispatch since we need to reload table */ \
+ /* data also. */ \
+ fastdecode_commitarr(dst, &farr, sizeof(upb_StringView)); \
+ data = ret.tag; \
+ UPB_MUSTTAIL return _upb_FastDecoder_TagDispatch(UPB_PARSE_ARGS); \
+ } \
+ goto again; \
+ case FD_NEXT_OTHERFIELD: \
+ data = ret.tag; \
+ UPB_MUSTTAIL return _upb_FastDecoder_TagDispatch(UPB_PARSE_ARGS); \
+ case FD_NEXT_ATLIMIT: \
+ return ptr; \
+ } \
+ } \
+ \
+ if (card != CARD_r && validate_utf8) { \
+ data = (uint64_t)dst; \
+ UPB_MUSTTAIL return fastdecode_verifyutf8(UPB_PARSE_ARGS); \
+ } \
+ \
+ UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
+
+/* Generate all combinations:
+ * {p,c} x {s,o,r} x {s, b} x {1bt,2bt} */
+
+#define s_VALIDATE true
+#define b_VALIDATE false
+
+#define F(card, tagbytes, type) \
+ UPB_NOINLINE \
+ const char* upb_c##card##type##_##tagbytes##bt(UPB_PARSE_PARAMS) { \
+ FASTDECODE_COPYSTRING(d, ptr, msg, table, hasbits, data, tagbytes, \
+ CARD_##card, type##_VALIDATE); \
+ } \
+ const char* upb_p##card##type##_##tagbytes##bt(UPB_PARSE_PARAMS) { \
+ FASTDECODE_STRING(d, ptr, msg, table, hasbits, data, tagbytes, \
+ CARD_##card, upb_c##card##type##_##tagbytes##bt, \
+ type##_VALIDATE); \
+ }
+
+#define UTF8(card, tagbytes) \
+ F(card, tagbytes, s) \
+ F(card, tagbytes, b)
+
+#define TAGBYTES(card) \
+ UTF8(card, 1) \
+ UTF8(card, 2)
+
+TAGBYTES(s)
+TAGBYTES(o)
+TAGBYTES(r)
+
+#undef s_VALIDATE
+#undef b_VALIDATE
+#undef F
+#undef TAGBYTES
+#undef FASTDECODE_LONGSTRING
+#undef FASTDECODE_COPYSTRING
+#undef FASTDECODE_STRING
+
+/* message fields *************************************************************/
+
+UPB_INLINE
+upb_Message* decode_newmsg_ceil(upb_Decoder* d, const upb_MiniTable* l,
+ int msg_ceil_bytes) {
+ size_t size = l->size + sizeof(upb_Message_Internal);
+ char* msg_data;
+ if (UPB_LIKELY(msg_ceil_bytes > 0 &&
+ _upb_ArenaHas(&d->arena) >= msg_ceil_bytes)) {
+ UPB_ASSERT(size <= (size_t)msg_ceil_bytes);
+ msg_data = d->arena.head.ptr;
+ d->arena.head.ptr += size;
+ UPB_UNPOISON_MEMORY_REGION(msg_data, msg_ceil_bytes);
+ memset(msg_data, 0, msg_ceil_bytes);
+ UPB_POISON_MEMORY_REGION(msg_data + size, msg_ceil_bytes - size);
+ } else {
+ msg_data = (char*)upb_Arena_Malloc(&d->arena, size);
+ memset(msg_data, 0, size);
+ }
+ return msg_data + sizeof(upb_Message_Internal);
+}
+
+typedef struct {
+ intptr_t table;
+ upb_Message* msg;
+} fastdecode_submsgdata;
+
+UPB_FORCEINLINE
+static const char* fastdecode_tosubmsg(upb_Decoder* d, const char* ptr,
+ void* ctx) {
+ fastdecode_submsgdata* submsg = ctx;
+ ptr = fastdecode_dispatch(d, ptr, submsg->msg, submsg->table, 0, 0);
+ UPB_ASSUME(ptr != NULL);
+ return ptr;
+}
+
+#define FASTDECODE_SUBMSG(d, ptr, msg, table, hasbits, data, tagbytes, \
+ msg_ceil_bytes, card) \
+ \
+ if (UPB_UNLIKELY(!fastdecode_checktag(data, tagbytes))) { \
+ RETURN_GENERIC("submessage field tag mismatch\n"); \
+ } \
+ \
+ if (--d->depth == 0) { \
+ _upb_FastDecoder_ErrorJmp(d, kUpb_DecodeStatus_MaxDepthExceeded); \
+ } \
+ \
+ upb_Message** dst; \
+ uint32_t submsg_idx = (data >> 16) & 0xff; \
+ const upb_MiniTable* tablep = decode_totablep(table); \
+ const upb_MiniTable* subtablep = tablep->subs[submsg_idx].submsg; \
+ fastdecode_submsgdata submsg = {decode_totable(subtablep)}; \
+ fastdecode_arr farr; \
+ \
+ if (subtablep->table_mask == (uint8_t)-1) { \
+ RETURN_GENERIC("submessage doesn't have fast tables."); \
+ } \
+ \
+ dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &farr, \
+ sizeof(upb_Message*), card); \
+ \
+ if (card == CARD_s) { \
+ *(uint32_t*)msg |= hasbits; \
+ hasbits = 0; \
+ } \
+ \
+ again: \
+ if (card == CARD_r) { \
+ dst = fastdecode_resizearr(d, dst, &farr, sizeof(upb_Message*)); \
+ } \
+ \
+ submsg.msg = *dst; \
+ \
+ if (card == CARD_r || UPB_LIKELY(!submsg.msg)) { \
+ *dst = submsg.msg = decode_newmsg_ceil(d, subtablep, msg_ceil_bytes); \
+ } \
+ \
+ ptr += tagbytes; \
+ ptr = fastdecode_delimited(d, ptr, fastdecode_tosubmsg, &submsg); \
+ \
+ if (UPB_UNLIKELY(ptr == NULL || d->end_group != DECODE_NOGROUP)) { \
+ _upb_FastDecoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed); \
+ } \
+ \
+ if (card == CARD_r) { \
+ fastdecode_nextret ret = fastdecode_nextrepeated( \
+ d, dst, &ptr, &farr, data, tagbytes, sizeof(upb_Message*)); \
+ switch (ret.next) { \
+ case FD_NEXT_SAMEFIELD: \
+ dst = ret.dst; \
+ goto again; \
+ case FD_NEXT_OTHERFIELD: \
+ d->depth++; \
+ data = ret.tag; \
+ UPB_MUSTTAIL return _upb_FastDecoder_TagDispatch(UPB_PARSE_ARGS); \
+ case FD_NEXT_ATLIMIT: \
+ d->depth++; \
+ return ptr; \
+ } \
+ } \
+ \
+ d->depth++; \
+ UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
+
+#define F(card, tagbytes, size_ceil, ceil_arg) \
+ const char* upb_p##card##m_##tagbytes##bt_max##size_ceil##b( \
+ UPB_PARSE_PARAMS) { \
+ FASTDECODE_SUBMSG(d, ptr, msg, table, hasbits, data, tagbytes, ceil_arg, \
+ CARD_##card); \
+ }
+
+#define SIZES(card, tagbytes) \
+ F(card, tagbytes, 64, 64) \
+ F(card, tagbytes, 128, 128) \
+ F(card, tagbytes, 192, 192) \
+ F(card, tagbytes, 256, 256) \
+ F(card, tagbytes, max, -1)
+
+#define TAGBYTES(card) \
+ SIZES(card, 1) \
+ SIZES(card, 2)
+
+TAGBYTES(s)
+TAGBYTES(o)
+TAGBYTES(r)
+
+#undef TAGBYTES
+#undef SIZES
+#undef F
+#undef FASTDECODE_SUBMSG
+
+#endif /* UPB_FASTTABLE */
+
+
+#include <errno.h>
+#include <float.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+// Must be last.
+
+typedef struct {
+ const char *ptr, *end;
+ upb_Arena* arena; /* TODO: should we have a tmp arena for tmp data? */
+ const upb_DefPool* symtab;
+ int depth;
+ upb_Status* status;
+ jmp_buf err;
+ int line;
+ const char* line_begin;
+ bool is_first;
+ int options;
+ const upb_FieldDef* debug_field;
+} jsondec;
+
+enum { JD_OBJECT, JD_ARRAY, JD_STRING, JD_NUMBER, JD_TRUE, JD_FALSE, JD_NULL };
+
+/* Forward declarations of mutually-recursive functions. */
+static void jsondec_wellknown(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m);
+static upb_MessageValue jsondec_value(jsondec* d, const upb_FieldDef* f);
+static void jsondec_wellknownvalue(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m);
+static void jsondec_object(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m);
+
+static bool jsondec_streql(upb_StringView str, const char* lit) {
+ return str.size == strlen(lit) && memcmp(str.data, lit, str.size) == 0;
+}
+
+static bool jsondec_isnullvalue(const upb_FieldDef* f) {
+ return upb_FieldDef_CType(f) == kUpb_CType_Enum &&
+ strcmp(upb_EnumDef_FullName(upb_FieldDef_EnumSubDef(f)),
+ "google.protobuf.NullValue") == 0;
+}
+
+static bool jsondec_isvalue(const upb_FieldDef* f) {
+ return (upb_FieldDef_CType(f) == kUpb_CType_Message &&
+ upb_MessageDef_WellKnownType(upb_FieldDef_MessageSubDef(f)) ==
+ kUpb_WellKnown_Value) ||
+ jsondec_isnullvalue(f);
+}
+
+UPB_NORETURN static void jsondec_err(jsondec* d, const char* msg) {
+ upb_Status_SetErrorFormat(d->status, "Error parsing JSON @%d:%d: %s", d->line,
+ (int)(d->ptr - d->line_begin), msg);
+ UPB_LONGJMP(d->err, 1);
+}
+
+UPB_PRINTF(2, 3)
+UPB_NORETURN static void jsondec_errf(jsondec* d, const char* fmt, ...) {
+ va_list argp;
+ upb_Status_SetErrorFormat(d->status, "Error parsing JSON @%d:%d: ", d->line,
+ (int)(d->ptr - d->line_begin));
+ va_start(argp, fmt);
+ upb_Status_VAppendErrorFormat(d->status, fmt, argp);
+ va_end(argp);
+ UPB_LONGJMP(d->err, 1);
+}
+
+static void jsondec_skipws(jsondec* d) {
+ while (d->ptr != d->end) {
+ switch (*d->ptr) {
+ case '\n':
+ d->line++;
+ d->line_begin = d->ptr;
+ /* Fallthrough. */
+ case '\r':
+ case '\t':
+ case ' ':
+ d->ptr++;
+ break;
+ default:
+ return;
+ }
+ }
+ jsondec_err(d, "Unexpected EOF");
+}
+
+static bool jsondec_tryparsech(jsondec* d, char ch) {
+ if (d->ptr == d->end || *d->ptr != ch) return false;
+ d->ptr++;
+ return true;
+}
+
+static void jsondec_parselit(jsondec* d, const char* lit) {
+ size_t avail = d->end - d->ptr;
+ size_t len = strlen(lit);
+ if (avail < len || memcmp(d->ptr, lit, len) != 0) {
+ jsondec_errf(d, "Expected: '%s'", lit);
+ }
+ d->ptr += len;
+}
+
+static void jsondec_wsch(jsondec* d, char ch) {
+ jsondec_skipws(d);
+ if (!jsondec_tryparsech(d, ch)) {
+ jsondec_errf(d, "Expected: '%c'", ch);
+ }
+}
+
+static void jsondec_true(jsondec* d) { jsondec_parselit(d, "true"); }
+static void jsondec_false(jsondec* d) { jsondec_parselit(d, "false"); }
+static void jsondec_null(jsondec* d) { jsondec_parselit(d, "null"); }
+
+static void jsondec_entrysep(jsondec* d) {
+ jsondec_skipws(d);
+ jsondec_parselit(d, ":");
+}
+
+static int jsondec_rawpeek(jsondec* d) {
+ switch (*d->ptr) {
+ case '{':
+ return JD_OBJECT;
+ case '[':
+ return JD_ARRAY;
+ case '"':
+ return JD_STRING;
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ return JD_NUMBER;
+ case 't':
+ return JD_TRUE;
+ case 'f':
+ return JD_FALSE;
+ case 'n':
+ return JD_NULL;
+ default:
+ jsondec_errf(d, "Unexpected character: '%c'", *d->ptr);
+ }
+}
+
+/* JSON object/array **********************************************************/
+
+/* These are used like so:
+ *
+ * jsondec_objstart(d);
+ * while (jsondec_objnext(d)) {
+ * ...
+ * }
+ * jsondec_objend(d) */
+
+static int jsondec_peek(jsondec* d) {
+ jsondec_skipws(d);
+ return jsondec_rawpeek(d);
+}
+
+static void jsondec_push(jsondec* d) {
+ if (--d->depth < 0) {
+ jsondec_err(d, "Recursion limit exceeded");
+ }
+ d->is_first = true;
+}
+
+static bool jsondec_seqnext(jsondec* d, char end_ch) {
+ bool is_first = d->is_first;
+ d->is_first = false;
+ jsondec_skipws(d);
+ if (*d->ptr == end_ch) return false;
+ if (!is_first) jsondec_parselit(d, ",");
+ return true;
+}
+
+static void jsondec_arrstart(jsondec* d) {
+ jsondec_push(d);
+ jsondec_wsch(d, '[');
+}
+
+static void jsondec_arrend(jsondec* d) {
+ d->depth++;
+ jsondec_wsch(d, ']');
+}
+
+static bool jsondec_arrnext(jsondec* d) { return jsondec_seqnext(d, ']'); }
+
+static void jsondec_objstart(jsondec* d) {
+ jsondec_push(d);
+ jsondec_wsch(d, '{');
+}
+
+static void jsondec_objend(jsondec* d) {
+ d->depth++;
+ jsondec_wsch(d, '}');
+}
+
+static bool jsondec_objnext(jsondec* d) {
+ if (!jsondec_seqnext(d, '}')) return false;
+ if (jsondec_peek(d) != JD_STRING) {
+ jsondec_err(d, "Object must start with string");
+ }
+ return true;
+}
+
+/* JSON number ****************************************************************/
+
+static bool jsondec_tryskipdigits(jsondec* d) {
+ const char* start = d->ptr;
+
+ while (d->ptr < d->end) {
+ if (*d->ptr < '0' || *d->ptr > '9') {
+ break;
+ }
+ d->ptr++;
+ }
+
+ return d->ptr != start;
+}
+
+static void jsondec_skipdigits(jsondec* d) {
+ if (!jsondec_tryskipdigits(d)) {
+ jsondec_err(d, "Expected one or more digits");
+ }
+}
+
+static double jsondec_number(jsondec* d) {
+ const char* start = d->ptr;
+
+ assert(jsondec_rawpeek(d) == JD_NUMBER);
+
+ /* Skip over the syntax of a number, as specified by JSON. */
+ if (*d->ptr == '-') d->ptr++;
+
+ if (jsondec_tryparsech(d, '0')) {
+ if (jsondec_tryskipdigits(d)) {
+ jsondec_err(d, "number cannot have leading zero");
+ }
+ } else {
+ jsondec_skipdigits(d);
+ }
+
+ if (d->ptr == d->end) goto parse;
+ if (jsondec_tryparsech(d, '.')) {
+ jsondec_skipdigits(d);
+ }
+ if (d->ptr == d->end) goto parse;
+
+ if (*d->ptr == 'e' || *d->ptr == 'E') {
+ d->ptr++;
+ if (d->ptr == d->end) {
+ jsondec_err(d, "Unexpected EOF in number");
+ }
+ if (*d->ptr == '+' || *d->ptr == '-') {
+ d->ptr++;
+ }
+ jsondec_skipdigits(d);
+ }
+
+parse:
+ /* Having verified the syntax of a JSON number, use strtod() to parse
+ * (strtod() accepts a superset of JSON syntax). */
+ errno = 0;
+ {
+ char* end;
+ double val = strtod(start, &end);
+ assert(end == d->ptr);
+
+ /* Currently the min/max-val conformance tests fail if we check this. Does
+ * this mean the conformance tests are wrong or strtod() is wrong, or
+ * something else? Investigate further. */
+ /*
+ if (errno == ERANGE) {
+ jsondec_err(d, "Number out of range");
+ }
+ */
+
+ if (val > DBL_MAX || val < -DBL_MAX) {
+ jsondec_err(d, "Number out of range");
+ }
+
+ return val;
+ }
+}
+
+/* JSON string ****************************************************************/
+
+static char jsondec_escape(jsondec* d) {
+ switch (*d->ptr++) {
+ case '"':
+ return '\"';
+ case '\\':
+ return '\\';
+ case '/':
+ return '/';
+ case 'b':
+ return '\b';
+ case 'f':
+ return '\f';
+ case 'n':
+ return '\n';
+ case 'r':
+ return '\r';
+ case 't':
+ return '\t';
+ default:
+ jsondec_err(d, "Invalid escape char");
+ }
+}
+
+static uint32_t jsondec_codepoint(jsondec* d) {
+ uint32_t cp = 0;
+ const char* end;
+
+ if (d->end - d->ptr < 4) {
+ jsondec_err(d, "EOF inside string");
+ }
+
+ end = d->ptr + 4;
+ while (d->ptr < end) {
+ char ch = *d->ptr++;
+ if (ch >= '0' && ch <= '9') {
+ ch -= '0';
+ } else if (ch >= 'a' && ch <= 'f') {
+ ch = ch - 'a' + 10;
+ } else if (ch >= 'A' && ch <= 'F') {
+ ch = ch - 'A' + 10;
+ } else {
+ jsondec_err(d, "Invalid hex digit");
+ }
+ cp = (cp << 4) | ch;
+ }
+
+ return cp;
+}
+
+/* Parses a \uXXXX unicode escape (possibly a surrogate pair). */
+static size_t jsondec_unicode(jsondec* d, char* out) {
+ uint32_t cp = jsondec_codepoint(d);
+ if (upb_Unicode_IsHigh(cp)) {
+ /* Surrogate pair: two 16-bit codepoints become a 32-bit codepoint. */
+ jsondec_parselit(d, "\\u");
+ uint32_t low = jsondec_codepoint(d);
+ if (!upb_Unicode_IsLow(low)) jsondec_err(d, "Invalid low surrogate");
+ cp = upb_Unicode_FromPair(cp, low);
+ } else if (upb_Unicode_IsLow(cp)) {
+ jsondec_err(d, "Unpaired low surrogate");
+ }
+
+ /* Write to UTF-8 */
+ int bytes = upb_Unicode_ToUTF8(cp, out);
+ if (bytes == 0) jsondec_err(d, "Invalid codepoint");
+ return bytes;
+}
+
+static void jsondec_resize(jsondec* d, char** buf, char** end, char** buf_end) {
+ size_t oldsize = *buf_end - *buf;
+ size_t len = *end - *buf;
+ size_t size = UPB_MAX(8, 2 * oldsize);
+
+ *buf = upb_Arena_Realloc(d->arena, *buf, len, size);
+ if (!*buf) jsondec_err(d, "Out of memory");
+
+ *end = *buf + len;
+ *buf_end = *buf + size;
+}
+
+static upb_StringView jsondec_string(jsondec* d) {
+ char* buf = NULL;
+ char* end = NULL;
+ char* buf_end = NULL;
+
+ jsondec_skipws(d);
+
+ if (*d->ptr++ != '"') {
+ jsondec_err(d, "Expected string");
+ }
+
+ while (d->ptr < d->end) {
+ char ch = *d->ptr++;
+
+ if (end == buf_end) {
+ jsondec_resize(d, &buf, &end, &buf_end);
+ }
+
+ switch (ch) {
+ case '"': {
+ upb_StringView ret;
+ ret.data = buf;
+ ret.size = end - buf;
+ *end = '\0'; /* Needed for possible strtod(). */
+ return ret;
+ }
+ case '\\':
+ if (d->ptr == d->end) goto eof;
+ if (*d->ptr == 'u') {
+ d->ptr++;
+ if (buf_end - end < 4) {
+ /* Allow space for maximum-sized codepoint (4 bytes). */
+ jsondec_resize(d, &buf, &end, &buf_end);
+ }
+ end += jsondec_unicode(d, end);
+ } else {
+ *end++ = jsondec_escape(d);
+ }
+ break;
+ default:
+ if ((unsigned char)*d->ptr < 0x20) {
+ jsondec_err(d, "Invalid char in JSON string");
+ }
+ *end++ = ch;
+ break;
+ }
+ }
+
+eof:
+ jsondec_err(d, "EOF inside string");
+}
+
+static void jsondec_skipval(jsondec* d) {
+ switch (jsondec_peek(d)) {
+ case JD_OBJECT:
+ jsondec_objstart(d);
+ while (jsondec_objnext(d)) {
+ jsondec_string(d);
+ jsondec_entrysep(d);
+ jsondec_skipval(d);
+ }
+ jsondec_objend(d);
+ break;
+ case JD_ARRAY:
+ jsondec_arrstart(d);
+ while (jsondec_arrnext(d)) {
+ jsondec_skipval(d);
+ }
+ jsondec_arrend(d);
+ break;
+ case JD_TRUE:
+ jsondec_true(d);
+ break;
+ case JD_FALSE:
+ jsondec_false(d);
+ break;
+ case JD_NULL:
+ jsondec_null(d);
+ break;
+ case JD_STRING:
+ jsondec_string(d);
+ break;
+ case JD_NUMBER:
+ jsondec_number(d);
+ break;
+ }
+}
+
+/* Base64 decoding for bytes fields. ******************************************/
+
+static unsigned int jsondec_base64_tablelookup(const char ch) {
+ /* Table includes the normal base64 chars plus the URL-safe variant. */
+ const signed char table[256] = {
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, 62 /*+*/, -1, 62 /*-*/, -1, 63 /*/ */, 52 /*0*/,
+ 53 /*1*/, 54 /*2*/, 55 /*3*/, 56 /*4*/, 57 /*5*/, 58 /*6*/, 59 /*7*/,
+ 60 /*8*/, 61 /*9*/, -1, -1, -1, -1, -1,
+ -1, -1, 0 /*A*/, 1 /*B*/, 2 /*C*/, 3 /*D*/, 4 /*E*/,
+ 5 /*F*/, 6 /*G*/, 07 /*H*/, 8 /*I*/, 9 /*J*/, 10 /*K*/, 11 /*L*/,
+ 12 /*M*/, 13 /*N*/, 14 /*O*/, 15 /*P*/, 16 /*Q*/, 17 /*R*/, 18 /*S*/,
+ 19 /*T*/, 20 /*U*/, 21 /*V*/, 22 /*W*/, 23 /*X*/, 24 /*Y*/, 25 /*Z*/,
+ -1, -1, -1, -1, 63 /*_*/, -1, 26 /*a*/,
+ 27 /*b*/, 28 /*c*/, 29 /*d*/, 30 /*e*/, 31 /*f*/, 32 /*g*/, 33 /*h*/,
+ 34 /*i*/, 35 /*j*/, 36 /*k*/, 37 /*l*/, 38 /*m*/, 39 /*n*/, 40 /*o*/,
+ 41 /*p*/, 42 /*q*/, 43 /*r*/, 44 /*s*/, 45 /*t*/, 46 /*u*/, 47 /*v*/,
+ 48 /*w*/, 49 /*x*/, 50 /*y*/, 51 /*z*/, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1};
+
+ /* Sign-extend return value so high bit will be set on any unexpected char. */
+ return table[(unsigned)ch];
+}
+
+static char* jsondec_partialbase64(jsondec* d, const char* ptr, const char* end,
+ char* out) {
+ int32_t val = -1;
+
+ switch (end - ptr) {
+ case 2:
+ val = jsondec_base64_tablelookup(ptr[0]) << 18 |
+ jsondec_base64_tablelookup(ptr[1]) << 12;
+ out[0] = val >> 16;
+ out += 1;
+ break;
+ case 3:
+ val = jsondec_base64_tablelookup(ptr[0]) << 18 |
+ jsondec_base64_tablelookup(ptr[1]) << 12 |
+ jsondec_base64_tablelookup(ptr[2]) << 6;
+ out[0] = val >> 16;
+ out[1] = (val >> 8) & 0xff;
+ out += 2;
+ break;
+ }
+
+ if (val < 0) {
+ jsondec_err(d, "Corrupt base64");
+ }
+
+ return out;
+}
+
+static size_t jsondec_base64(jsondec* d, upb_StringView str) {
+ /* We decode in place. This is safe because this is a new buffer (not
+ * aliasing the input) and because base64 decoding shrinks 4 bytes into 3. */
+ char* out = (char*)str.data;
+ const char* ptr = str.data;
+ const char* end = ptr + str.size;
+ const char* end4 = ptr + (str.size & -4); /* Round down to multiple of 4. */
+
+ for (; ptr < end4; ptr += 4, out += 3) {
+ int val = jsondec_base64_tablelookup(ptr[0]) << 18 |
+ jsondec_base64_tablelookup(ptr[1]) << 12 |
+ jsondec_base64_tablelookup(ptr[2]) << 6 |
+ jsondec_base64_tablelookup(ptr[3]) << 0;
+
+ if (val < 0) {
+ /* Junk chars or padding. Remove trailing padding, if any. */
+ if (end - ptr == 4 && ptr[3] == '=') {
+ if (ptr[2] == '=') {
+ end -= 2;
+ } else {
+ end -= 1;
+ }
+ }
+ break;
+ }
+
+ out[0] = val >> 16;
+ out[1] = (val >> 8) & 0xff;
+ out[2] = val & 0xff;
+ }
+
+ if (ptr < end) {
+ /* Process remaining chars. We do not require padding. */
+ out = jsondec_partialbase64(d, ptr, end, out);
+ }
+
+ return out - str.data;
+}
+
+/* Low-level integer parsing **************************************************/
+
+static const char* jsondec_buftouint64(jsondec* d, const char* ptr,
+ const char* end, uint64_t* val) {
+ const char* out = upb_BufToUint64(ptr, end, val);
+ if (!out) jsondec_err(d, "Integer overflow");
+ return out;
+}
+
+static const char* jsondec_buftoint64(jsondec* d, const char* ptr,
+ const char* end, int64_t* val,
+ bool* is_neg) {
+ const char* out = upb_BufToInt64(ptr, end, val, is_neg);
+ if (!out) jsondec_err(d, "Integer overflow");
+ return out;
+}
+
+static uint64_t jsondec_strtouint64(jsondec* d, upb_StringView str) {
+ const char* end = str.data + str.size;
+ uint64_t ret;
+ if (jsondec_buftouint64(d, str.data, end, &ret) != end) {
+ jsondec_err(d, "Non-number characters in quoted integer");
+ }
+ return ret;
+}
+
+static int64_t jsondec_strtoint64(jsondec* d, upb_StringView str) {
+ const char* end = str.data + str.size;
+ int64_t ret;
+ if (jsondec_buftoint64(d, str.data, end, &ret, NULL) != end) {
+ jsondec_err(d, "Non-number characters in quoted integer");
+ }
+ return ret;
+}
+
+/* Primitive value types ******************************************************/
+
+/* Parse INT32 or INT64 value. */
+static upb_MessageValue jsondec_int(jsondec* d, const upb_FieldDef* f) {
+ upb_MessageValue val;
+
+ switch (jsondec_peek(d)) {
+ case JD_NUMBER: {
+ double dbl = jsondec_number(d);
+ if (dbl > 9223372036854774784.0 || dbl < -9223372036854775808.0) {
+ jsondec_err(d, "JSON number is out of range.");
+ }
+ val.int64_val = dbl; /* must be guarded, overflow here is UB */
+ if (val.int64_val != dbl) {
+ jsondec_errf(d, "JSON number was not integral (%f != %" PRId64 ")", dbl,
+ val.int64_val);
+ }
+ break;
+ }
+ case JD_STRING: {
+ upb_StringView str = jsondec_string(d);
+ val.int64_val = jsondec_strtoint64(d, str);
+ break;
+ }
+ default:
+ jsondec_err(d, "Expected number or string");
+ }
+
+ if (upb_FieldDef_CType(f) == kUpb_CType_Int32 ||
+ upb_FieldDef_CType(f) == kUpb_CType_Enum) {
+ if (val.int64_val > INT32_MAX || val.int64_val < INT32_MIN) {
+ jsondec_err(d, "Integer out of range.");
+ }
+ val.int32_val = (int32_t)val.int64_val;
+ }
+
+ return val;
+}
+
+/* Parse UINT32 or UINT64 value. */
+static upb_MessageValue jsondec_uint(jsondec* d, const upb_FieldDef* f) {
+ upb_MessageValue val = {0};
+
+ switch (jsondec_peek(d)) {
+ case JD_NUMBER: {
+ double dbl = jsondec_number(d);
+ if (dbl > 18446744073709549568.0 || dbl < 0) {
+ jsondec_err(d, "JSON number is out of range.");
+ }
+ val.uint64_val = dbl; /* must be guarded, overflow here is UB */
+ if (val.uint64_val != dbl) {
+ jsondec_errf(d, "JSON number was not integral (%f != %" PRIu64 ")", dbl,
+ val.uint64_val);
+ }
+ break;
+ }
+ case JD_STRING: {
+ upb_StringView str = jsondec_string(d);
+ val.uint64_val = jsondec_strtouint64(d, str);
+ break;
+ }
+ default:
+ jsondec_err(d, "Expected number or string");
+ }
+
+ if (upb_FieldDef_CType(f) == kUpb_CType_UInt32) {
+ if (val.uint64_val > UINT32_MAX) {
+ jsondec_err(d, "Integer out of range.");
+ }
+ val.uint32_val = (uint32_t)val.uint64_val;
+ }
+
+ return val;
+}
+
+/* Parse DOUBLE or FLOAT value. */
+static upb_MessageValue jsondec_double(jsondec* d, const upb_FieldDef* f) {
+ upb_StringView str;
+ upb_MessageValue val = {0};
+
+ switch (jsondec_peek(d)) {
+ case JD_NUMBER:
+ val.double_val = jsondec_number(d);
+ break;
+ case JD_STRING:
+ str = jsondec_string(d);
+ if (jsondec_streql(str, "NaN")) {
+ val.double_val = NAN;
+ } else if (jsondec_streql(str, "Infinity")) {
+ val.double_val = INFINITY;
+ } else if (jsondec_streql(str, "-Infinity")) {
+ val.double_val = -INFINITY;
+ } else {
+ val.double_val = strtod(str.data, NULL);
+ }
+ break;
+ default:
+ jsondec_err(d, "Expected number or string");
+ }
+
+ if (upb_FieldDef_CType(f) == kUpb_CType_Float) {
+ float f = val.double_val;
+ if (val.double_val != INFINITY && val.double_val != -INFINITY) {
+ if (f == INFINITY || f == -INFINITY) jsondec_err(d, "Float out of range");
+ }
+ val.float_val = f;
+ }
+
+ return val;
+}
+
+/* Parse STRING or BYTES value. */
+static upb_MessageValue jsondec_strfield(jsondec* d, const upb_FieldDef* f) {
+ upb_MessageValue val;
+ val.str_val = jsondec_string(d);
+ if (upb_FieldDef_CType(f) == kUpb_CType_Bytes) {
+ val.str_val.size = jsondec_base64(d, val.str_val);
+ }
+ return val;
+}
+
+static upb_MessageValue jsondec_enum(jsondec* d, const upb_FieldDef* f) {
+ switch (jsondec_peek(d)) {
+ case JD_STRING: {
+ upb_StringView str = jsondec_string(d);
+ const upb_EnumDef* e = upb_FieldDef_EnumSubDef(f);
+ const upb_EnumValueDef* ev =
+ upb_EnumDef_FindValueByNameWithSize(e, str.data, str.size);
+ upb_MessageValue val;
+ if (ev) {
+ val.int32_val = upb_EnumValueDef_Number(ev);
+ } else {
+ if (d->options & upb_JsonDecode_IgnoreUnknown) {
+ val.int32_val = 0;
+ } else {
+ jsondec_errf(d, "Unknown enumerator: '" UPB_STRINGVIEW_FORMAT "'",
+ UPB_STRINGVIEW_ARGS(str));
+ }
+ }
+ return val;
+ }
+ case JD_NULL: {
+ if (jsondec_isnullvalue(f)) {
+ upb_MessageValue val;
+ jsondec_null(d);
+ val.int32_val = 0;
+ return val;
+ }
+ }
+ /* Fallthrough. */
+ default:
+ return jsondec_int(d, f);
+ }
+}
+
+static upb_MessageValue jsondec_bool(jsondec* d, const upb_FieldDef* f) {
+ bool is_map_key = upb_FieldDef_Number(f) == 1 &&
+ upb_MessageDef_IsMapEntry(upb_FieldDef_ContainingType(f));
+ upb_MessageValue val;
+
+ if (is_map_key) {
+ upb_StringView str = jsondec_string(d);
+ if (jsondec_streql(str, "true")) {
+ val.bool_val = true;
+ } else if (jsondec_streql(str, "false")) {
+ val.bool_val = false;
+ } else {
+ jsondec_err(d, "Invalid boolean map key");
+ }
+ } else {
+ switch (jsondec_peek(d)) {
+ case JD_TRUE:
+ val.bool_val = true;
+ jsondec_true(d);
+ break;
+ case JD_FALSE:
+ val.bool_val = false;
+ jsondec_false(d);
+ break;
+ default:
+ jsondec_err(d, "Expected true or false");
+ }
+ }
+
+ return val;
+}
+
+/* Composite types (array/message/map) ****************************************/
+
+static void jsondec_array(jsondec* d, upb_Message* msg, const upb_FieldDef* f) {
+ upb_Array* arr = upb_Message_Mutable(msg, f, d->arena).array;
+
+ jsondec_arrstart(d);
+ while (jsondec_arrnext(d)) {
+ upb_MessageValue elem = jsondec_value(d, f);
+ upb_Array_Append(arr, elem, d->arena);
+ }
+ jsondec_arrend(d);
+}
+
+static void jsondec_map(jsondec* d, upb_Message* msg, const upb_FieldDef* f) {
+ upb_Map* map = upb_Message_Mutable(msg, f, d->arena).map;
+ const upb_MessageDef* entry = upb_FieldDef_MessageSubDef(f);
+ const upb_FieldDef* key_f = upb_MessageDef_FindFieldByNumber(entry, 1);
+ const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(entry, 2);
+
+ jsondec_objstart(d);
+ while (jsondec_objnext(d)) {
+ upb_MessageValue key, val;
+ key = jsondec_value(d, key_f);
+ jsondec_entrysep(d);
+ val = jsondec_value(d, val_f);
+ upb_Map_Set(map, key, val, d->arena);
+ }
+ jsondec_objend(d);
+}
+
+static void jsondec_tomsg(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ if (upb_MessageDef_WellKnownType(m) == kUpb_WellKnown_Unspecified) {
+ jsondec_object(d, msg, m);
+ } else {
+ jsondec_wellknown(d, msg, m);
+ }
+}
+
+static upb_MessageValue jsondec_msg(jsondec* d, const upb_FieldDef* f) {
+ const upb_MessageDef* m = upb_FieldDef_MessageSubDef(f);
+ upb_Message* msg = upb_Message_New(m, d->arena);
+ upb_MessageValue val;
+
+ jsondec_tomsg(d, msg, m);
+ val.msg_val = msg;
+ return val;
+}
+
+static void jsondec_field(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ upb_StringView name;
+ const upb_FieldDef* f;
+ const upb_FieldDef* preserved;
+
+ name = jsondec_string(d);
+ jsondec_entrysep(d);
+
+ if (name.size >= 2 && name.data[0] == '[' &&
+ name.data[name.size - 1] == ']') {
+ f = upb_DefPool_FindExtensionByNameWithSize(d->symtab, name.data + 1,
+ name.size - 2);
+ if (f && upb_FieldDef_ContainingType(f) != m) {
+ jsondec_errf(
+ d, "Extension %s extends message %s, but was seen in message %s",
+ upb_FieldDef_FullName(f),
+ upb_MessageDef_FullName(upb_FieldDef_ContainingType(f)),
+ upb_MessageDef_FullName(m));
+ }
+ } else {
+ f = upb_MessageDef_FindByJsonNameWithSize(m, name.data, name.size);
+ }
+
+ if (!f) {
+ if ((d->options & upb_JsonDecode_IgnoreUnknown) == 0) {
+ jsondec_errf(d, "No such field: " UPB_STRINGVIEW_FORMAT,
+ UPB_STRINGVIEW_ARGS(name));
+ }
+ jsondec_skipval(d);
+ return;
+ }
+
+ if (jsondec_peek(d) == JD_NULL && !jsondec_isvalue(f)) {
+ /* JSON "null" indicates a default value, so no need to set anything. */
+ jsondec_null(d);
+ return;
+ }
+
+ if (upb_FieldDef_RealContainingOneof(f) &&
+ upb_Message_WhichOneof(msg, upb_FieldDef_ContainingOneof(f))) {
+ jsondec_err(d, "More than one field for this oneof.");
+ }
+
+ preserved = d->debug_field;
+ d->debug_field = f;
+
+ if (upb_FieldDef_IsMap(f)) {
+ jsondec_map(d, msg, f);
+ } else if (upb_FieldDef_IsRepeated(f)) {
+ jsondec_array(d, msg, f);
+ } else if (upb_FieldDef_IsSubMessage(f)) {
+ upb_Message* submsg = upb_Message_Mutable(msg, f, d->arena).msg;
+ const upb_MessageDef* subm = upb_FieldDef_MessageSubDef(f);
+ jsondec_tomsg(d, submsg, subm);
+ } else {
+ upb_MessageValue val = jsondec_value(d, f);
+ upb_Message_Set(msg, f, val, d->arena);
+ }
+
+ d->debug_field = preserved;
+}
+
+static void jsondec_object(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ jsondec_objstart(d);
+ while (jsondec_objnext(d)) {
+ jsondec_field(d, msg, m);
+ }
+ jsondec_objend(d);
+}
+
+static upb_MessageValue jsondec_value(jsondec* d, const upb_FieldDef* f) {
+ switch (upb_FieldDef_CType(f)) {
+ case kUpb_CType_Bool:
+ return jsondec_bool(d, f);
+ case kUpb_CType_Float:
+ case kUpb_CType_Double:
+ return jsondec_double(d, f);
+ case kUpb_CType_UInt32:
+ case kUpb_CType_UInt64:
+ return jsondec_uint(d, f);
+ case kUpb_CType_Int32:
+ case kUpb_CType_Int64:
+ return jsondec_int(d, f);
+ case kUpb_CType_String:
+ case kUpb_CType_Bytes:
+ return jsondec_strfield(d, f);
+ case kUpb_CType_Enum:
+ return jsondec_enum(d, f);
+ case kUpb_CType_Message:
+ return jsondec_msg(d, f);
+ default:
+ UPB_UNREACHABLE();
+ }
+}
+
+/* Well-known types ***********************************************************/
+
+static int jsondec_tsdigits(jsondec* d, const char** ptr, size_t digits,
+ const char* after) {
+ uint64_t val;
+ const char* p = *ptr;
+ const char* end = p + digits;
+ size_t after_len = after ? strlen(after) : 0;
+
+ UPB_ASSERT(digits <= 9); /* int can't overflow. */
+
+ if (jsondec_buftouint64(d, p, end, &val) != end ||
+ (after_len && memcmp(end, after, after_len) != 0)) {
+ jsondec_err(d, "Malformed timestamp");
+ }
+
+ UPB_ASSERT(val < INT_MAX);
+
+ *ptr = end + after_len;
+ return (int)val;
+}
+
+static int jsondec_nanos(jsondec* d, const char** ptr, const char* end) {
+ uint64_t nanos = 0;
+ const char* p = *ptr;
+
+ if (p != end && *p == '.') {
+ const char* nano_end = jsondec_buftouint64(d, p + 1, end, &nanos);
+ int digits = (int)(nano_end - p - 1);
+ int exp_lg10 = 9 - digits;
+ if (digits > 9) {
+ jsondec_err(d, "Too many digits for partial seconds");
+ }
+ while (exp_lg10--) nanos *= 10;
+ *ptr = nano_end;
+ }
+
+ UPB_ASSERT(nanos < INT_MAX);
+
+ return (int)nanos;
+}
+
+/* jsondec_epochdays(1970, 1, 1) == 1970-01-01 == 0. */
+int jsondec_epochdays(int y, int m, int d) {
+ const uint32_t year_base = 4800; /* Before min year, multiple of 400. */
+ const uint32_t m_adj = m - 3; /* March-based month. */
+ const uint32_t carry = m_adj > (uint32_t)m ? 1 : 0;
+ const uint32_t adjust = carry ? 12 : 0;
+ const uint32_t y_adj = y + year_base - carry;
+ const uint32_t month_days = ((m_adj + adjust) * 62719 + 769) / 2048;
+ const uint32_t leap_days = y_adj / 4 - y_adj / 100 + y_adj / 400;
+ return y_adj * 365 + leap_days + month_days + (d - 1) - 2472632;
+}
+
+static int64_t jsondec_unixtime(int y, int m, int d, int h, int min, int s) {
+ return (int64_t)jsondec_epochdays(y, m, d) * 86400 + h * 3600 + min * 60 + s;
+}
+
+static void jsondec_timestamp(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ upb_MessageValue seconds;
+ upb_MessageValue nanos;
+ upb_StringView str = jsondec_string(d);
+ const char* ptr = str.data;
+ const char* end = ptr + str.size;
+
+ if (str.size < 20) goto malformed;
+
+ {
+ /* 1972-01-01T01:00:00 */
+ int year = jsondec_tsdigits(d, &ptr, 4, "-");
+ int mon = jsondec_tsdigits(d, &ptr, 2, "-");
+ int day = jsondec_tsdigits(d, &ptr, 2, "T");
+ int hour = jsondec_tsdigits(d, &ptr, 2, ":");
+ int min = jsondec_tsdigits(d, &ptr, 2, ":");
+ int sec = jsondec_tsdigits(d, &ptr, 2, NULL);
+
+ seconds.int64_val = jsondec_unixtime(year, mon, day, hour, min, sec);
+ }
+
+ nanos.int32_val = jsondec_nanos(d, &ptr, end);
+
+ {
+ /* [+-]08:00 or Z */
+ int ofs_hour = 0;
+ int ofs_min = 0;
+ bool neg = false;
+
+ if (ptr == end) goto malformed;
+
+ switch (*ptr++) {
+ case '-':
+ neg = true;
+ /* fallthrough */
+ case '+':
+ if ((end - ptr) != 5) goto malformed;
+ ofs_hour = jsondec_tsdigits(d, &ptr, 2, ":");
+ ofs_min = jsondec_tsdigits(d, &ptr, 2, NULL);
+ ofs_min = ((ofs_hour * 60) + ofs_min) * 60;
+ seconds.int64_val += (neg ? ofs_min : -ofs_min);
+ break;
+ case 'Z':
+ if (ptr != end) goto malformed;
+ break;
+ default:
+ goto malformed;
+ }
+ }
+
+ if (seconds.int64_val < -62135596800) {
+ jsondec_err(d, "Timestamp out of range");
+ }
+
+ upb_Message_Set(msg, upb_MessageDef_FindFieldByNumber(m, 1), seconds,
+ d->arena);
+ upb_Message_Set(msg, upb_MessageDef_FindFieldByNumber(m, 2), nanos, d->arena);
+ return;
+
+malformed:
+ jsondec_err(d, "Malformed timestamp");
+}
+
+static void jsondec_duration(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ upb_MessageValue seconds;
+ upb_MessageValue nanos;
+ upb_StringView str = jsondec_string(d);
+ const char* ptr = str.data;
+ const char* end = ptr + str.size;
+ const int64_t max = (uint64_t)3652500 * 86400;
+ bool neg = false;
+
+ /* "3.000000001s", "3s", etc. */
+ ptr = jsondec_buftoint64(d, ptr, end, &seconds.int64_val, &neg);
+ nanos.int32_val = jsondec_nanos(d, &ptr, end);
+
+ if (end - ptr != 1 || *ptr != 's') {
+ jsondec_err(d, "Malformed duration");
+ }
+
+ if (seconds.int64_val < -max || seconds.int64_val > max) {
+ jsondec_err(d, "Duration out of range");
+ }
+
+ if (neg) {
+ nanos.int32_val = -nanos.int32_val;
+ }
+
+ upb_Message_Set(msg, upb_MessageDef_FindFieldByNumber(m, 1), seconds,
+ d->arena);
+ upb_Message_Set(msg, upb_MessageDef_FindFieldByNumber(m, 2), nanos, d->arena);
+}
+
+static void jsondec_listvalue(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ const upb_FieldDef* values_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ const upb_MessageDef* value_m = upb_FieldDef_MessageSubDef(values_f);
+ upb_Array* values = upb_Message_Mutable(msg, values_f, d->arena).array;
+
+ jsondec_arrstart(d);
+ while (jsondec_arrnext(d)) {
+ upb_Message* value_msg = upb_Message_New(value_m, d->arena);
+ upb_MessageValue value;
+ value.msg_val = value_msg;
+ upb_Array_Append(values, value, d->arena);
+ jsondec_wellknownvalue(d, value_msg, value_m);
+ }
+ jsondec_arrend(d);
+}
+
+static void jsondec_struct(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ const upb_FieldDef* fields_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(fields_f);
+ const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(entry_m, 2);
+ const upb_MessageDef* value_m = upb_FieldDef_MessageSubDef(value_f);
+ upb_Map* fields = upb_Message_Mutable(msg, fields_f, d->arena).map;
+
+ jsondec_objstart(d);
+ while (jsondec_objnext(d)) {
+ upb_MessageValue key, value;
+ upb_Message* value_msg = upb_Message_New(value_m, d->arena);
+ key.str_val = jsondec_string(d);
+ value.msg_val = value_msg;
+ upb_Map_Set(fields, key, value, d->arena);
+ jsondec_entrysep(d);
+ jsondec_wellknownvalue(d, value_msg, value_m);
+ }
+ jsondec_objend(d);
+}
+
+static void jsondec_wellknownvalue(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ upb_MessageValue val;
+ const upb_FieldDef* f;
+ upb_Message* submsg;
+
+ switch (jsondec_peek(d)) {
+ case JD_NUMBER:
+ /* double number_value = 2; */
+ f = upb_MessageDef_FindFieldByNumber(m, 2);
+ val.double_val = jsondec_number(d);
+ break;
+ case JD_STRING:
+ /* string string_value = 3; */
+ f = upb_MessageDef_FindFieldByNumber(m, 3);
+ val.str_val = jsondec_string(d);
+ break;
+ case JD_FALSE:
+ /* bool bool_value = 4; */
+ f = upb_MessageDef_FindFieldByNumber(m, 4);
+ val.bool_val = false;
+ jsondec_false(d);
+ break;
+ case JD_TRUE:
+ /* bool bool_value = 4; */
+ f = upb_MessageDef_FindFieldByNumber(m, 4);
+ val.bool_val = true;
+ jsondec_true(d);
+ break;
+ case JD_NULL:
+ /* NullValue null_value = 1; */
+ f = upb_MessageDef_FindFieldByNumber(m, 1);
+ val.int32_val = 0;
+ jsondec_null(d);
+ break;
+ /* Note: these cases return, because upb_Message_Mutable() is enough. */
+ case JD_OBJECT:
+ /* Struct struct_value = 5; */
+ f = upb_MessageDef_FindFieldByNumber(m, 5);
+ submsg = upb_Message_Mutable(msg, f, d->arena).msg;
+ jsondec_struct(d, submsg, upb_FieldDef_MessageSubDef(f));
+ return;
+ case JD_ARRAY:
+ /* ListValue list_value = 6; */
+ f = upb_MessageDef_FindFieldByNumber(m, 6);
+ submsg = upb_Message_Mutable(msg, f, d->arena).msg;
+ jsondec_listvalue(d, submsg, upb_FieldDef_MessageSubDef(f));
+ return;
+ default:
+ UPB_UNREACHABLE();
+ }
+
+ upb_Message_Set(msg, f, val, d->arena);
+}
+
+static upb_StringView jsondec_mask(jsondec* d, const char* buf,
+ const char* end) {
+ /* FieldMask fields grow due to inserted '_' characters, so we can't do the
+ * transform in place. */
+ const char* ptr = buf;
+ upb_StringView ret;
+ char* out;
+
+ ret.size = end - ptr;
+ while (ptr < end) {
+ ret.size += (*ptr >= 'A' && *ptr <= 'Z');
+ ptr++;
+ }
+
+ out = upb_Arena_Malloc(d->arena, ret.size);
+ ptr = buf;
+ ret.data = out;
+
+ while (ptr < end) {
+ char ch = *ptr++;
+ if (ch >= 'A' && ch <= 'Z') {
+ *out++ = '_';
+ *out++ = ch + 32;
+ } else if (ch == '_') {
+ jsondec_err(d, "field mask may not contain '_'");
+ } else {
+ *out++ = ch;
+ }
+ }
+
+ return ret;
+}
+
+static void jsondec_fieldmask(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ /* repeated string paths = 1; */
+ const upb_FieldDef* paths_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ upb_Array* arr = upb_Message_Mutable(msg, paths_f, d->arena).array;
+ upb_StringView str = jsondec_string(d);
+ const char* ptr = str.data;
+ const char* end = ptr + str.size;
+ upb_MessageValue val;
+
+ while (ptr < end) {
+ const char* elem_end = memchr(ptr, ',', end - ptr);
+ if (elem_end) {
+ val.str_val = jsondec_mask(d, ptr, elem_end);
+ ptr = elem_end + 1;
+ } else {
+ val.str_val = jsondec_mask(d, ptr, end);
+ ptr = end;
+ }
+ upb_Array_Append(arr, val, d->arena);
+ }
+}
+
+static void jsondec_anyfield(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ if (upb_MessageDef_WellKnownType(m) == kUpb_WellKnown_Unspecified) {
+ /* For regular types: {"@type": "[user type]", "f1": <V1>, "f2": <V2>}
+ * where f1, f2, etc. are the normal fields of this type. */
+ jsondec_field(d, msg, m);
+ } else {
+ /* For well-known types: {"@type": "[well-known type]", "value": <X>}
+ * where <X> is whatever encoding the WKT normally uses. */
+ upb_StringView str = jsondec_string(d);
+ jsondec_entrysep(d);
+ if (!jsondec_streql(str, "value")) {
+ jsondec_err(d, "Key for well-known type must be 'value'");
+ }
+ jsondec_wellknown(d, msg, m);
+ }
+}
+
+static const upb_MessageDef* jsondec_typeurl(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ const upb_FieldDef* type_url_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ const upb_MessageDef* type_m;
+ upb_StringView type_url = jsondec_string(d);
+ const char* end = type_url.data + type_url.size;
+ const char* ptr = end;
+ upb_MessageValue val;
+
+ val.str_val = type_url;
+ upb_Message_Set(msg, type_url_f, val, d->arena);
+
+ /* Find message name after the last '/' */
+ while (ptr > type_url.data && *--ptr != '/') {
+ }
+
+ if (ptr == type_url.data || ptr == end) {
+ jsondec_err(d, "Type url must have at least one '/' and non-empty host");
+ }
+
+ ptr++;
+ type_m = upb_DefPool_FindMessageByNameWithSize(d->symtab, ptr, end - ptr);
+
+ if (!type_m) {
+ jsondec_err(d, "Type was not found");
+ }
+
+ return type_m;
+}
+
+static void jsondec_any(jsondec* d, upb_Message* msg, const upb_MessageDef* m) {
+ /* string type_url = 1;
+ * bytes value = 2; */
+ const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(m, 2);
+ upb_Message* any_msg;
+ const upb_MessageDef* any_m = NULL;
+ const char* pre_type_data = NULL;
+ const char* pre_type_end = NULL;
+ upb_MessageValue encoded;
+
+ jsondec_objstart(d);
+
+ /* Scan looking for "@type", which is not necessarily first. */
+ while (!any_m && jsondec_objnext(d)) {
+ const char* start = d->ptr;
+ upb_StringView name = jsondec_string(d);
+ jsondec_entrysep(d);
+ if (jsondec_streql(name, "@type")) {
+ any_m = jsondec_typeurl(d, msg, m);
+ if (pre_type_data) {
+ pre_type_end = start;
+ while (*pre_type_end != ',') pre_type_end--;
+ }
+ } else {
+ if (!pre_type_data) pre_type_data = start;
+ jsondec_skipval(d);
+ }
+ }
+
+ if (!any_m) {
+ jsondec_err(d, "Any object didn't contain a '@type' field");
+ }
+
+ any_msg = upb_Message_New(any_m, d->arena);
+
+ if (pre_type_data) {
+ size_t len = pre_type_end - pre_type_data + 1;
+ char* tmp = upb_Arena_Malloc(d->arena, len);
+ const char* saved_ptr = d->ptr;
+ const char* saved_end = d->end;
+ memcpy(tmp, pre_type_data, len - 1);
+ tmp[len - 1] = '}';
+ d->ptr = tmp;
+ d->end = tmp + len;
+ d->is_first = true;
+ while (jsondec_objnext(d)) {
+ jsondec_anyfield(d, any_msg, any_m);
+ }
+ d->ptr = saved_ptr;
+ d->end = saved_end;
+ }
+
+ while (jsondec_objnext(d)) {
+ jsondec_anyfield(d, any_msg, any_m);
+ }
+
+ jsondec_objend(d);
+
+ upb_EncodeStatus status =
+ upb_Encode(any_msg, upb_MessageDef_MiniTable(any_m), 0, d->arena,
+ (char**)&encoded.str_val.data, &encoded.str_val.size);
+ // TODO(b/235839510): We should fail gracefully here on a bad return status.
+ UPB_ASSERT(status == kUpb_EncodeStatus_Ok);
+ upb_Message_Set(msg, value_f, encoded, d->arena);
+}
+
+static void jsondec_wrapper(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ upb_MessageValue val = jsondec_value(d, value_f);
+ upb_Message_Set(msg, value_f, val, d->arena);
+}
+
+static void jsondec_wellknown(jsondec* d, upb_Message* msg,
+ const upb_MessageDef* m) {
+ switch (upb_MessageDef_WellKnownType(m)) {
+ case kUpb_WellKnown_Any:
+ jsondec_any(d, msg, m);
+ break;
+ case kUpb_WellKnown_FieldMask:
+ jsondec_fieldmask(d, msg, m);
+ break;
+ case kUpb_WellKnown_Duration:
+ jsondec_duration(d, msg, m);
+ break;
+ case kUpb_WellKnown_Timestamp:
+ jsondec_timestamp(d, msg, m);
+ break;
+ case kUpb_WellKnown_Value:
+ jsondec_wellknownvalue(d, msg, m);
+ break;
+ case kUpb_WellKnown_ListValue:
+ jsondec_listvalue(d, msg, m);
+ break;
+ case kUpb_WellKnown_Struct:
+ jsondec_struct(d, msg, m);
+ break;
+ case kUpb_WellKnown_DoubleValue:
+ case kUpb_WellKnown_FloatValue:
+ case kUpb_WellKnown_Int64Value:
+ case kUpb_WellKnown_UInt64Value:
+ case kUpb_WellKnown_Int32Value:
+ case kUpb_WellKnown_UInt32Value:
+ case kUpb_WellKnown_StringValue:
+ case kUpb_WellKnown_BytesValue:
+ case kUpb_WellKnown_BoolValue:
+ jsondec_wrapper(d, msg, m);
+ break;
+ default:
+ UPB_UNREACHABLE();
+ }
+}
+
+bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg,
+ const upb_MessageDef* m, const upb_DefPool* symtab,
+ int options, upb_Arena* arena, upb_Status* status) {
+ jsondec d;
+
+ if (size == 0) return true;
+
+ d.ptr = buf;
+ d.end = buf + size;
+ d.arena = arena;
+ d.symtab = symtab;
+ d.status = status;
+ d.options = options;
+ d.depth = 64;
+ d.line = 1;
+ d.line_begin = d.ptr;
+ d.debug_field = NULL;
+ d.is_first = false;
+
+ if (UPB_SETJMP(d.err)) return false;
+
+ jsondec_tomsg(&d, msg, m);
+ return true;
+}
+
+
+#include <ctype.h>
+#include <float.h>
+#include <inttypes.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+
+// Must be last.
+
+typedef struct {
+ char *buf, *ptr, *end;
+ size_t overflow;
+ int indent_depth;
+ int options;
+ const upb_DefPool* ext_pool;
+ jmp_buf err;
+ upb_Status* status;
+ upb_Arena* arena;
+} jsonenc;
+
+static void jsonenc_msg(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m);
+static void jsonenc_scalar(jsonenc* e, upb_MessageValue val,
+ const upb_FieldDef* f);
+static void jsonenc_msgfield(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m);
+static void jsonenc_msgfields(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m, bool first);
+static void jsonenc_value(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m);
+
+UPB_NORETURN static void jsonenc_err(jsonenc* e, const char* msg) {
+ upb_Status_SetErrorMessage(e->status, msg);
+ longjmp(e->err, 1);
+}
+
+UPB_PRINTF(2, 3)
+UPB_NORETURN static void jsonenc_errf(jsonenc* e, const char* fmt, ...) {
+ va_list argp;
+ va_start(argp, fmt);
+ upb_Status_VSetErrorFormat(e->status, fmt, argp);
+ va_end(argp);
+ longjmp(e->err, 1);
+}
+
+static upb_Arena* jsonenc_arena(jsonenc* e) {
+ /* Create lazily, since it's only needed for Any */
+ if (!e->arena) {
+ e->arena = upb_Arena_New();
+ }
+ return e->arena;
+}
+
+static void jsonenc_putbytes(jsonenc* e, const void* data, size_t len) {
+ size_t have = e->end - e->ptr;
+ if (UPB_LIKELY(have >= len)) {
+ memcpy(e->ptr, data, len);
+ e->ptr += len;
+ } else {
+ if (have) {
+ memcpy(e->ptr, data, have);
+ e->ptr += have;
+ }
+ e->overflow += (len - have);
+ }
+}
+
+static void jsonenc_putstr(jsonenc* e, const char* str) {
+ jsonenc_putbytes(e, str, strlen(str));
+}
+
+UPB_PRINTF(2, 3)
+static void jsonenc_printf(jsonenc* e, const char* fmt, ...) {
+ size_t n;
+ size_t have = e->end - e->ptr;
+ va_list args;
+
+ va_start(args, fmt);
+ n = _upb_vsnprintf(e->ptr, have, fmt, args);
+ va_end(args);
+
+ if (UPB_LIKELY(have > n)) {
+ e->ptr += n;
+ } else {
+ e->ptr = UPB_PTRADD(e->ptr, have);
+ e->overflow += (n - have);
+ }
+}
+
+static void jsonenc_nanos(jsonenc* e, int32_t nanos) {
+ int digits = 9;
+
+ if (nanos == 0) return;
+ if (nanos < 0 || nanos >= 1000000000) {
+ jsonenc_err(e, "error formatting timestamp as JSON: invalid nanos");
+ }
+
+ while (nanos % 1000 == 0) {
+ nanos /= 1000;
+ digits -= 3;
+ }
+
+ jsonenc_printf(e, ".%.*" PRId32, digits, nanos);
+}
+
+static void jsonenc_timestamp(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m) {
+ const upb_FieldDef* seconds_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ const upb_FieldDef* nanos_f = upb_MessageDef_FindFieldByNumber(m, 2);
+ int64_t seconds = upb_Message_Get(msg, seconds_f).int64_val;
+ int32_t nanos = upb_Message_Get(msg, nanos_f).int32_val;
+ int L, N, I, J, K, hour, min, sec;
+
+ if (seconds < -62135596800) {
+ jsonenc_err(e,
+ "error formatting timestamp as JSON: minimum acceptable value "
+ "is 0001-01-01T00:00:00Z");
+ } else if (seconds > 253402300799) {
+ jsonenc_err(e,
+ "error formatting timestamp as JSON: maximum acceptable value "
+ "is 9999-12-31T23:59:59Z");
+ }
+
+ /* Julian Day -> Y/M/D, Algorithm from:
+ * Fliegel, H. F., and Van Flandern, T. C., "A Machine Algorithm for
+ * Processing Calendar Dates," Communications of the Association of
+ * Computing Machines, vol. 11 (1968), p. 657. */
+ seconds += 62135596800; // Ensure seconds is positive.
+ L = (int)(seconds / 86400) - 719162 + 68569 + 2440588;
+ N = 4 * L / 146097;
+ L = L - (146097 * N + 3) / 4;
+ I = 4000 * (L + 1) / 1461001;
+ L = L - 1461 * I / 4 + 31;
+ J = 80 * L / 2447;
+ K = L - 2447 * J / 80;
+ L = J / 11;
+ J = J + 2 - 12 * L;
+ I = 100 * (N - 49) + I + L;
+
+ sec = seconds % 60;
+ min = (seconds / 60) % 60;
+ hour = (seconds / 3600) % 24;
+
+ jsonenc_printf(e, "\"%04d-%02d-%02dT%02d:%02d:%02d", I, J, K, hour, min, sec);
+ jsonenc_nanos(e, nanos);
+ jsonenc_putstr(e, "Z\"");
+}
+
+static void jsonenc_duration(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m) {
+ const upb_FieldDef* seconds_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ const upb_FieldDef* nanos_f = upb_MessageDef_FindFieldByNumber(m, 2);
+ int64_t seconds = upb_Message_Get(msg, seconds_f).int64_val;
+ int32_t nanos = upb_Message_Get(msg, nanos_f).int32_val;
+ bool negative = false;
+
+ if (seconds > 315576000000 || seconds < -315576000000 ||
+ (seconds != 0 && nanos != 0 && (seconds < 0) != (nanos < 0))) {
+ jsonenc_err(e, "bad duration");
+ }
+
+ if (seconds < 0) {
+ negative = true;
+ seconds = -seconds;
+ }
+ if (nanos < 0) {
+ negative = true;
+ nanos = -nanos;
+ }
+
+ jsonenc_putstr(e, "\"");
+ if (negative) {
+ jsonenc_putstr(e, "-");
+ }
+ jsonenc_printf(e, "%" PRId64, seconds);
+ jsonenc_nanos(e, nanos);
+ jsonenc_putstr(e, "s\"");
+}
+
+static void jsonenc_enum(int32_t val, const upb_FieldDef* f, jsonenc* e) {
+ const upb_EnumDef* e_def = upb_FieldDef_EnumSubDef(f);
+
+ if (strcmp(upb_EnumDef_FullName(e_def), "google.protobuf.NullValue") == 0) {
+ jsonenc_putstr(e, "null");
+ } else {
+ const upb_EnumValueDef* ev =
+ (e->options & upb_JsonEncode_FormatEnumsAsIntegers)
+ ? NULL
+ : upb_EnumDef_FindValueByNumber(e_def, val);
+
+ if (ev) {
+ jsonenc_printf(e, "\"%s\"", upb_EnumValueDef_Name(ev));
+ } else {
+ jsonenc_printf(e, "%" PRId32, val);
+ }
+ }
+}
+
+static void jsonenc_bytes(jsonenc* e, upb_StringView str) {
+ /* This is the regular base64, not the "web-safe" version. */
+ static const char base64[] =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+ const unsigned char* ptr = (unsigned char*)str.data;
+ const unsigned char* end = UPB_PTRADD(ptr, str.size);
+ char buf[4];
+
+ jsonenc_putstr(e, "\"");
+
+ while (end - ptr >= 3) {
+ buf[0] = base64[ptr[0] >> 2];
+ buf[1] = base64[((ptr[0] & 0x3) << 4) | (ptr[1] >> 4)];
+ buf[2] = base64[((ptr[1] & 0xf) << 2) | (ptr[2] >> 6)];
+ buf[3] = base64[ptr[2] & 0x3f];
+ jsonenc_putbytes(e, buf, 4);
+ ptr += 3;
+ }
+
+ switch (end - ptr) {
+ case 2:
+ buf[0] = base64[ptr[0] >> 2];
+ buf[1] = base64[((ptr[0] & 0x3) << 4) | (ptr[1] >> 4)];
+ buf[2] = base64[(ptr[1] & 0xf) << 2];
+ buf[3] = '=';
+ jsonenc_putbytes(e, buf, 4);
+ break;
+ case 1:
+ buf[0] = base64[ptr[0] >> 2];
+ buf[1] = base64[((ptr[0] & 0x3) << 4)];
+ buf[2] = '=';
+ buf[3] = '=';
+ jsonenc_putbytes(e, buf, 4);
+ break;
+ }
+
+ jsonenc_putstr(e, "\"");
+}
+
+static void jsonenc_stringbody(jsonenc* e, upb_StringView str) {
+ const char* ptr = str.data;
+ const char* end = UPB_PTRADD(ptr, str.size);
+
+ while (ptr < end) {
+ switch (*ptr) {
+ case '\n':
+ jsonenc_putstr(e, "\\n");
+ break;
+ case '\r':
+ jsonenc_putstr(e, "\\r");
+ break;
+ case '\t':
+ jsonenc_putstr(e, "\\t");
+ break;
+ case '\"':
+ jsonenc_putstr(e, "\\\"");
+ break;
+ case '\f':
+ jsonenc_putstr(e, "\\f");
+ break;
+ case '\b':
+ jsonenc_putstr(e, "\\b");
+ break;
+ case '\\':
+ jsonenc_putstr(e, "\\\\");
+ break;
+ default:
+ if ((uint8_t)*ptr < 0x20) {
+ jsonenc_printf(e, "\\u%04x", (int)(uint8_t)*ptr);
+ } else {
+ /* This could be a non-ASCII byte. We rely on the string being valid
+ * UTF-8. */
+ jsonenc_putbytes(e, ptr, 1);
+ }
+ break;
+ }
+ ptr++;
+ }
+}
+
+static void jsonenc_string(jsonenc* e, upb_StringView str) {
+ jsonenc_putstr(e, "\"");
+ jsonenc_stringbody(e, str);
+ jsonenc_putstr(e, "\"");
+}
+
+static bool upb_JsonEncode_HandleSpecialDoubles(jsonenc* e, double val) {
+ if (val == INFINITY) {
+ jsonenc_putstr(e, "\"Infinity\"");
+ } else if (val == -INFINITY) {
+ jsonenc_putstr(e, "\"-Infinity\"");
+ } else if (val != val) {
+ jsonenc_putstr(e, "\"NaN\"");
+ } else {
+ return false;
+ }
+ return true;
+}
+
+static void upb_JsonEncode_Double(jsonenc* e, double val) {
+ if (upb_JsonEncode_HandleSpecialDoubles(e, val)) return;
+ char buf[32];
+ _upb_EncodeRoundTripDouble(val, buf, sizeof(buf));
+ jsonenc_putstr(e, buf);
+}
+
+static void upb_JsonEncode_Float(jsonenc* e, float val) {
+ if (upb_JsonEncode_HandleSpecialDoubles(e, val)) return;
+ char buf[32];
+ _upb_EncodeRoundTripFloat(val, buf, sizeof(buf));
+ jsonenc_putstr(e, buf);
+}
+
+static void jsonenc_wrapper(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m) {
+ const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ upb_MessageValue val = upb_Message_Get(msg, val_f);
+ jsonenc_scalar(e, val, val_f);
+}
+
+static const upb_MessageDef* jsonenc_getanymsg(jsonenc* e,
+ upb_StringView type_url) {
+ /* Find last '/', if any. */
+ const char* end = type_url.data + type_url.size;
+ const char* ptr = end;
+ const upb_MessageDef* ret;
+
+ if (!e->ext_pool) {
+ jsonenc_err(e, "Tried to encode Any, but no symtab was provided");
+ }
+
+ if (type_url.size == 0) goto badurl;
+
+ while (true) {
+ if (--ptr == type_url.data) {
+ /* Type URL must contain at least one '/', with host before. */
+ goto badurl;
+ }
+ if (*ptr == '/') {
+ ptr++;
+ break;
+ }
+ }
+
+ ret = upb_DefPool_FindMessageByNameWithSize(e->ext_pool, ptr, end - ptr);
+
+ if (!ret) {
+ jsonenc_errf(e, "Couldn't find Any type: %.*s", (int)(end - ptr), ptr);
+ }
+
+ return ret;
+
+badurl:
+ jsonenc_errf(e, "Bad type URL: " UPB_STRINGVIEW_FORMAT,
+ UPB_STRINGVIEW_ARGS(type_url));
+}
+
+static void jsonenc_any(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m) {
+ const upb_FieldDef* type_url_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(m, 2);
+ upb_StringView type_url = upb_Message_Get(msg, type_url_f).str_val;
+ upb_StringView value = upb_Message_Get(msg, value_f).str_val;
+ const upb_MessageDef* any_m = jsonenc_getanymsg(e, type_url);
+ const upb_MiniTable* any_layout = upb_MessageDef_MiniTable(any_m);
+ upb_Arena* arena = jsonenc_arena(e);
+ upb_Message* any = upb_Message_New(any_m, arena);
+
+ if (upb_Decode(value.data, value.size, any, any_layout, NULL, 0, arena) !=
+ kUpb_DecodeStatus_Ok) {
+ jsonenc_err(e, "Error decoding message in Any");
+ }
+
+ jsonenc_putstr(e, "{\"@type\":");
+ jsonenc_string(e, type_url);
+
+ if (upb_MessageDef_WellKnownType(any_m) == kUpb_WellKnown_Unspecified) {
+ /* Regular messages: {"@type": "...","foo": 1, "bar": 2} */
+ jsonenc_msgfields(e, any, any_m, false);
+ } else {
+ /* Well-known type: {"@type": "...","value": <well-known encoding>} */
+ jsonenc_putstr(e, ",\"value\":");
+ jsonenc_msgfield(e, any, any_m);
+ }
+
+ jsonenc_putstr(e, "}");
+}
+
+static void jsonenc_putsep(jsonenc* e, const char* str, bool* first) {
+ if (*first) {
+ *first = false;
+ } else {
+ jsonenc_putstr(e, str);
+ }
+}
+
+static void jsonenc_fieldpath(jsonenc* e, upb_StringView path) {
+ const char* ptr = path.data;
+ const char* end = ptr + path.size;
+
+ while (ptr < end) {
+ char ch = *ptr;
+
+ if (ch >= 'A' && ch <= 'Z') {
+ jsonenc_err(e, "Field mask element may not have upper-case letter.");
+ } else if (ch == '_') {
+ if (ptr == end - 1 || *(ptr + 1) < 'a' || *(ptr + 1) > 'z') {
+ jsonenc_err(e, "Underscore must be followed by a lowercase letter.");
+ }
+ ch = *++ptr - 32;
+ }
+
+ jsonenc_putbytes(e, &ch, 1);
+ ptr++;
+ }
+}
+
+static void jsonenc_fieldmask(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m) {
+ const upb_FieldDef* paths_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ const upb_Array* paths = upb_Message_Get(msg, paths_f).array_val;
+ bool first = true;
+ size_t i, n = 0;
+
+ if (paths) n = upb_Array_Size(paths);
+
+ jsonenc_putstr(e, "\"");
+
+ for (i = 0; i < n; i++) {
+ jsonenc_putsep(e, ",", &first);
+ jsonenc_fieldpath(e, upb_Array_Get(paths, i).str_val);
+ }
+
+ jsonenc_putstr(e, "\"");
+}
+
+static void jsonenc_struct(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m) {
+ const upb_FieldDef* fields_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ const upb_Map* fields = upb_Message_Get(msg, fields_f).map_val;
+ const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(fields_f);
+ const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(entry_m, 2);
+ size_t iter = kUpb_Map_Begin;
+ bool first = true;
+
+ jsonenc_putstr(e, "{");
+
+ if (fields) {
+ while (upb_MapIterator_Next(fields, &iter)) {
+ upb_MessageValue key = upb_MapIterator_Key(fields, iter);
+ upb_MessageValue val = upb_MapIterator_Value(fields, iter);
+
+ jsonenc_putsep(e, ",", &first);
+ jsonenc_string(e, key.str_val);
+ jsonenc_putstr(e, ":");
+ jsonenc_value(e, val.msg_val, upb_FieldDef_MessageSubDef(value_f));
+ }
+ }
+
+ jsonenc_putstr(e, "}");
+}
+
+static void jsonenc_listvalue(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m) {
+ const upb_FieldDef* values_f = upb_MessageDef_FindFieldByNumber(m, 1);
+ const upb_MessageDef* values_m = upb_FieldDef_MessageSubDef(values_f);
+ const upb_Array* values = upb_Message_Get(msg, values_f).array_val;
+ size_t i;
+ bool first = true;
+
+ jsonenc_putstr(e, "[");
+
+ if (values) {
+ const size_t size = upb_Array_Size(values);
+ for (i = 0; i < size; i++) {
+ upb_MessageValue elem = upb_Array_Get(values, i);
+
+ jsonenc_putsep(e, ",", &first);
+ jsonenc_value(e, elem.msg_val, values_m);
+ }
+ }
+
+ jsonenc_putstr(e, "]");
+}
+
+static void jsonenc_value(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m) {
+ /* TODO(haberman): do we want a reflection method to get oneof case? */
+ size_t iter = kUpb_Message_Begin;
+ const upb_FieldDef* f;
+ upb_MessageValue val;
+
+ if (!upb_Message_Next(msg, m, NULL, &f, &val, &iter)) {
+ jsonenc_err(e, "No value set in Value proto");
+ }
+
+ switch (upb_FieldDef_Number(f)) {
+ case 1:
+ jsonenc_putstr(e, "null");
+ break;
+ case 2:
+ upb_JsonEncode_Double(e, val.double_val);
+ break;
+ case 3:
+ jsonenc_string(e, val.str_val);
+ break;
+ case 4:
+ jsonenc_putstr(e, val.bool_val ? "true" : "false");
+ break;
+ case 5:
+ jsonenc_struct(e, val.msg_val, upb_FieldDef_MessageSubDef(f));
+ break;
+ case 6:
+ jsonenc_listvalue(e, val.msg_val, upb_FieldDef_MessageSubDef(f));
+ break;
+ }
+}
+
+static void jsonenc_msgfield(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m) {
+ switch (upb_MessageDef_WellKnownType(m)) {
+ case kUpb_WellKnown_Unspecified:
+ jsonenc_msg(e, msg, m);
+ break;
+ case kUpb_WellKnown_Any:
+ jsonenc_any(e, msg, m);
+ break;
+ case kUpb_WellKnown_FieldMask:
+ jsonenc_fieldmask(e, msg, m);
+ break;
+ case kUpb_WellKnown_Duration:
+ jsonenc_duration(e, msg, m);
+ break;
+ case kUpb_WellKnown_Timestamp:
+ jsonenc_timestamp(e, msg, m);
+ break;
+ case kUpb_WellKnown_DoubleValue:
+ case kUpb_WellKnown_FloatValue:
+ case kUpb_WellKnown_Int64Value:
+ case kUpb_WellKnown_UInt64Value:
+ case kUpb_WellKnown_Int32Value:
+ case kUpb_WellKnown_UInt32Value:
+ case kUpb_WellKnown_StringValue:
+ case kUpb_WellKnown_BytesValue:
+ case kUpb_WellKnown_BoolValue:
+ jsonenc_wrapper(e, msg, m);
+ break;
+ case kUpb_WellKnown_Value:
+ jsonenc_value(e, msg, m);
+ break;
+ case kUpb_WellKnown_ListValue:
+ jsonenc_listvalue(e, msg, m);
+ break;
+ case kUpb_WellKnown_Struct:
+ jsonenc_struct(e, msg, m);
+ break;
+ }
+}
+
+static void jsonenc_scalar(jsonenc* e, upb_MessageValue val,
+ const upb_FieldDef* f) {
+ switch (upb_FieldDef_CType(f)) {
+ case kUpb_CType_Bool:
+ jsonenc_putstr(e, val.bool_val ? "true" : "false");
+ break;
+ case kUpb_CType_Float:
+ upb_JsonEncode_Float(e, val.float_val);
+ break;
+ case kUpb_CType_Double:
+ upb_JsonEncode_Double(e, val.double_val);
+ break;
+ case kUpb_CType_Int32:
+ jsonenc_printf(e, "%" PRId32, val.int32_val);
+ break;
+ case kUpb_CType_UInt32:
+ jsonenc_printf(e, "%" PRIu32, val.uint32_val);
+ break;
+ case kUpb_CType_Int64:
+ jsonenc_printf(e, "\"%" PRId64 "\"", val.int64_val);
+ break;
+ case kUpb_CType_UInt64:
+ jsonenc_printf(e, "\"%" PRIu64 "\"", val.uint64_val);
+ break;
+ case kUpb_CType_String:
+ jsonenc_string(e, val.str_val);
+ break;
+ case kUpb_CType_Bytes:
+ jsonenc_bytes(e, val.str_val);
+ break;
+ case kUpb_CType_Enum:
+ jsonenc_enum(val.int32_val, f, e);
+ break;
+ case kUpb_CType_Message:
+ jsonenc_msgfield(e, val.msg_val, upb_FieldDef_MessageSubDef(f));
+ break;
+ }
+}
+
+static void jsonenc_mapkey(jsonenc* e, upb_MessageValue val,
+ const upb_FieldDef* f) {
+ jsonenc_putstr(e, "\"");
+
+ switch (upb_FieldDef_CType(f)) {
+ case kUpb_CType_Bool:
+ jsonenc_putstr(e, val.bool_val ? "true" : "false");
+ break;
+ case kUpb_CType_Int32:
+ jsonenc_printf(e, "%" PRId32, val.int32_val);
+ break;
+ case kUpb_CType_UInt32:
+ jsonenc_printf(e, "%" PRIu32, val.uint32_val);
+ break;
+ case kUpb_CType_Int64:
+ jsonenc_printf(e, "%" PRId64, val.int64_val);
+ break;
+ case kUpb_CType_UInt64:
+ jsonenc_printf(e, "%" PRIu64, val.uint64_val);
+ break;
+ case kUpb_CType_String:
+ jsonenc_stringbody(e, val.str_val);
+ break;
+ default:
+ UPB_UNREACHABLE();
+ }
+
+ jsonenc_putstr(e, "\":");
+}
+
+static void jsonenc_array(jsonenc* e, const upb_Array* arr,
+ const upb_FieldDef* f) {
+ size_t i;
+ size_t size = arr ? upb_Array_Size(arr) : 0;
+ bool first = true;
+
+ jsonenc_putstr(e, "[");
+
+ for (i = 0; i < size; i++) {
+ jsonenc_putsep(e, ",", &first);
+ jsonenc_scalar(e, upb_Array_Get(arr, i), f);
+ }
+
+ jsonenc_putstr(e, "]");
+}
+
+static void jsonenc_map(jsonenc* e, const upb_Map* map, const upb_FieldDef* f) {
+ const upb_MessageDef* entry = upb_FieldDef_MessageSubDef(f);
+ const upb_FieldDef* key_f = upb_MessageDef_FindFieldByNumber(entry, 1);
+ const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(entry, 2);
+ size_t iter = kUpb_Map_Begin;
+ bool first = true;
+
+ jsonenc_putstr(e, "{");
+
+ if (map) {
+ while (upb_MapIterator_Next(map, &iter)) {
+ jsonenc_putsep(e, ",", &first);
+ jsonenc_mapkey(e, upb_MapIterator_Key(map, iter), key_f);
+ jsonenc_scalar(e, upb_MapIterator_Value(map, iter), val_f);
+ }
+ }
+
+ jsonenc_putstr(e, "}");
+}
+
+static void jsonenc_fieldval(jsonenc* e, const upb_FieldDef* f,
+ upb_MessageValue val, bool* first) {
+ const char* name;
+
+ jsonenc_putsep(e, ",", first);
+
+ if (upb_FieldDef_IsExtension(f)) {
+ // TODO: For MessageSet, I would have expected this to print the message
+ // name here, but Python doesn't appear to do this. We should do more
+ // research here about what various implementations do.
+ jsonenc_printf(e, "\"[%s]\":", upb_FieldDef_FullName(f));
+ } else {
+ if (e->options & upb_JsonEncode_UseProtoNames) {
+ name = upb_FieldDef_Name(f);
+ } else {
+ name = upb_FieldDef_JsonName(f);
+ }
+ jsonenc_printf(e, "\"%s\":", name);
+ }
+
+ if (upb_FieldDef_IsMap(f)) {
+ jsonenc_map(e, val.map_val, f);
+ } else if (upb_FieldDef_IsRepeated(f)) {
+ jsonenc_array(e, val.array_val, f);
+ } else {
+ jsonenc_scalar(e, val, f);
+ }
+}
+
+static void jsonenc_msgfields(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m, bool first) {
+ upb_MessageValue val;
+ const upb_FieldDef* f;
+
+ if (e->options & upb_JsonEncode_EmitDefaults) {
+ /* Iterate over all fields. */
+ int i = 0;
+ int n = upb_MessageDef_FieldCount(m);
+ for (i = 0; i < n; i++) {
+ f = upb_MessageDef_Field(m, i);
+ if (!upb_FieldDef_HasPresence(f) || upb_Message_Has(msg, f)) {
+ jsonenc_fieldval(e, f, upb_Message_Get(msg, f), &first);
+ }
+ }
+ } else {
+ /* Iterate over non-empty fields. */
+ size_t iter = kUpb_Message_Begin;
+ while (upb_Message_Next(msg, m, e->ext_pool, &f, &val, &iter)) {
+ jsonenc_fieldval(e, f, val, &first);
+ }
+ }
+}
+
+static void jsonenc_msg(jsonenc* e, const upb_Message* msg,
+ const upb_MessageDef* m) {
+ jsonenc_putstr(e, "{");
+ jsonenc_msgfields(e, msg, m, true);
+ jsonenc_putstr(e, "}");
+}
+
+static size_t jsonenc_nullz(jsonenc* e, size_t size) {
+ size_t ret = e->ptr - e->buf + e->overflow;
+
+ if (size > 0) {
+ if (e->ptr == e->end) e->ptr--;
+ *e->ptr = '\0';
+ }
+
+ return ret;
+}
+
+size_t upb_JsonEncode(const upb_Message* msg, const upb_MessageDef* m,
+ const upb_DefPool* ext_pool, int options, char* buf,
+ size_t size, upb_Status* status) {
+ jsonenc e;
+
+ e.buf = buf;
+ e.ptr = buf;
+ e.end = UPB_PTRADD(buf, size);
+ e.overflow = 0;
+ e.options = options;
+ e.ext_pool = ext_pool;
+ e.status = status;
+ e.arena = NULL;
+
+ if (setjmp(e.err)) return -1;
+
+ jsonenc_msgfield(&e, msg, m);
+ if (e.arena) upb_Arena_Free(e.arena);
+ return jsonenc_nullz(&e, size);
+}
+
+
+#include <inttypes.h>
+#include <setjmp.h>
+
+
+// Must be last.
+
+typedef enum {
+ kUpb_EncodedType_Double = 0,
+ kUpb_EncodedType_Float = 1,
+ kUpb_EncodedType_Fixed32 = 2,
+ kUpb_EncodedType_Fixed64 = 3,
+ kUpb_EncodedType_SFixed32 = 4,
+ kUpb_EncodedType_SFixed64 = 5,
+ kUpb_EncodedType_Int32 = 6,
+ kUpb_EncodedType_UInt32 = 7,
+ kUpb_EncodedType_SInt32 = 8,
+ kUpb_EncodedType_Int64 = 9,
+ kUpb_EncodedType_UInt64 = 10,
+ kUpb_EncodedType_SInt64 = 11,
+ kUpb_EncodedType_Enum = 12,
+ kUpb_EncodedType_Bool = 13,
+ kUpb_EncodedType_Bytes = 14,
+ kUpb_EncodedType_String = 15,
+ kUpb_EncodedType_Group = 16,
+ kUpb_EncodedType_Message = 17,
+
+ kUpb_EncodedType_RepeatedBase = 20,
+} upb_EncodedType;
+
+typedef enum {
+ kUpb_EncodedFieldModifier_FlipPacked = 1 << 0,
+ kUpb_EncodedFieldModifier_IsClosedEnum = 1 << 1,
+ // upb only.
+ kUpb_EncodedFieldModifier_IsProto3Singular = 1 << 2,
+ kUpb_EncodedFieldModifier_IsRequired = 1 << 3,
+} upb_EncodedFieldModifier;
+
+enum {
+ kUpb_EncodedValue_MinField = ' ',
+ kUpb_EncodedValue_MaxField = 'K',
+ kUpb_EncodedValue_MinModifier = 'L',
+ kUpb_EncodedValue_MaxModifier = '[',
+ kUpb_EncodedValue_End = '^',
+ kUpb_EncodedValue_MinSkip = '_',
+ kUpb_EncodedValue_MaxSkip = '~',
+ kUpb_EncodedValue_OneofSeparator = '~',
+ kUpb_EncodedValue_FieldSeparator = '|',
+ kUpb_EncodedValue_MinOneofField = ' ',
+ kUpb_EncodedValue_MaxOneofField = 'b',
+ kUpb_EncodedValue_MaxEnumMask = 'A',
+};
+
+char upb_ToBase92(int8_t ch) {
+ static const char kUpb_ToBase92[] = {
+ ' ', '!', '#', '$', '%', '&', '(', ')', '*', '+', ',', '-', '.', '/',
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=',
+ '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
+ 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
+ 'Z', '[', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
+ 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+ 'w', 'x', 'y', 'z', '{', '|', '}', '~',
+ };
+
+ UPB_ASSERT(0 <= ch && ch < 92);
+ return kUpb_ToBase92[ch];
+}
+
+char upb_FromBase92(uint8_t ch) {
+ static const int8_t kUpb_FromBase92[] = {
+ 0, 1, -1, 2, 3, 4, 5, -1, 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+ 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 58, 59, 60,
+ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
+ 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
+ };
+
+ if (' ' > ch || ch > '~') return -1;
+ return kUpb_FromBase92[ch - ' '];
+}
+
+bool upb_IsTypePackable(upb_FieldType type) {
+ // clang-format off
+ static const unsigned kUnpackableTypes =
+ (1 << kUpb_FieldType_String) |
+ (1 << kUpb_FieldType_Bytes) |
+ (1 << kUpb_FieldType_Message) |
+ (1 << kUpb_FieldType_Group);
+ // clang-format on
+ return (1 << type) & ~kUnpackableTypes;
+}
+
+/** upb_MtDataEncoder *********************************************************/
+
+typedef struct {
+ uint64_t present_values_mask;
+ uint32_t last_written_value;
+} upb_MtDataEncoderInternal_EnumState;
+
+typedef struct {
+ uint64_t msg_modifiers;
+ uint32_t last_field_num;
+ enum {
+ kUpb_OneofState_NotStarted,
+ kUpb_OneofState_StartedOneof,
+ kUpb_OneofState_EmittedOneofField,
+ } oneof_state;
+} upb_MtDataEncoderInternal_MsgState;
+
+typedef struct {
+ char* buf_start; // Only for checking kUpb_MtDataEncoder_MinSize.
+ union {
+ upb_MtDataEncoderInternal_EnumState enum_state;
+ upb_MtDataEncoderInternal_MsgState msg_state;
+ } state;
+} upb_MtDataEncoderInternal;
+
+static upb_MtDataEncoderInternal* upb_MtDataEncoder_GetInternal(
+ upb_MtDataEncoder* e, char* buf_start) {
+ UPB_ASSERT(sizeof(upb_MtDataEncoderInternal) <= sizeof(e->internal));
+ upb_MtDataEncoderInternal* ret = (upb_MtDataEncoderInternal*)e->internal;
+ ret->buf_start = buf_start;
+ return ret;
+}
+
+static char* upb_MtDataEncoder_Put(upb_MtDataEncoder* e, char* ptr, char ch) {
+ upb_MtDataEncoderInternal* in = (upb_MtDataEncoderInternal*)e->internal;
+ UPB_ASSERT(ptr - in->buf_start < kUpb_MtDataEncoder_MinSize);
+ if (ptr == e->end) return NULL;
+ *ptr++ = upb_ToBase92(ch);
+ return ptr;
+}
+
+static char* upb_MtDataEncoder_PutBase92Varint(upb_MtDataEncoder* e, char* ptr,
+ uint32_t val, int min, int max) {
+ int shift = _upb_Log2Ceiling(upb_FromBase92(max) - upb_FromBase92(min) + 1);
+ UPB_ASSERT(shift <= 6);
+ uint32_t mask = (1 << shift) - 1;
+ do {
+ uint32_t bits = val & mask;
+ ptr = upb_MtDataEncoder_Put(e, ptr, bits + upb_FromBase92(min));
+ if (!ptr) return NULL;
+ val >>= shift;
+ } while (val);
+ return ptr;
+}
+
+char* upb_MtDataEncoder_PutModifier(upb_MtDataEncoder* e, char* ptr,
+ uint64_t mod) {
+ if (mod) {
+ ptr = upb_MtDataEncoder_PutBase92Varint(e, ptr, mod,
+ kUpb_EncodedValue_MinModifier,
+ kUpb_EncodedValue_MaxModifier);
+ }
+ return ptr;
+}
+
+char* upb_MtDataEncoder_StartMessage(upb_MtDataEncoder* e, char* ptr,
+ uint64_t msg_mod) {
+ upb_MtDataEncoderInternal* in = upb_MtDataEncoder_GetInternal(e, ptr);
+ in->state.msg_state.msg_modifiers = msg_mod;
+ in->state.msg_state.last_field_num = 0;
+ in->state.msg_state.oneof_state = kUpb_OneofState_NotStarted;
+ return upb_MtDataEncoder_PutModifier(e, ptr, msg_mod);
+}
+
+char* upb_MtDataEncoder_PutField(upb_MtDataEncoder* e, char* ptr,
+ upb_FieldType type, uint32_t field_num,
+ uint64_t field_mod) {
+ static const char kUpb_TypeToEncoded[] = {
+ [kUpb_FieldType_Double] = kUpb_EncodedType_Double,
+ [kUpb_FieldType_Float] = kUpb_EncodedType_Float,
+ [kUpb_FieldType_Int64] = kUpb_EncodedType_Int64,
+ [kUpb_FieldType_UInt64] = kUpb_EncodedType_UInt64,
+ [kUpb_FieldType_Int32] = kUpb_EncodedType_Int32,
+ [kUpb_FieldType_Fixed64] = kUpb_EncodedType_Fixed64,
+ [kUpb_FieldType_Fixed32] = kUpb_EncodedType_Fixed32,
+ [kUpb_FieldType_Bool] = kUpb_EncodedType_Bool,
+ [kUpb_FieldType_String] = kUpb_EncodedType_String,
+ [kUpb_FieldType_Group] = kUpb_EncodedType_Group,
+ [kUpb_FieldType_Message] = kUpb_EncodedType_Message,
+ [kUpb_FieldType_Bytes] = kUpb_EncodedType_Bytes,
+ [kUpb_FieldType_UInt32] = kUpb_EncodedType_UInt32,
+ [kUpb_FieldType_Enum] = kUpb_EncodedType_Enum,
+ [kUpb_FieldType_SFixed32] = kUpb_EncodedType_SFixed32,
+ [kUpb_FieldType_SFixed64] = kUpb_EncodedType_SFixed64,
+ [kUpb_FieldType_SInt32] = kUpb_EncodedType_SInt32,
+ [kUpb_FieldType_SInt64] = kUpb_EncodedType_SInt64,
+ };
+
+ upb_MtDataEncoderInternal* in = upb_MtDataEncoder_GetInternal(e, ptr);
+ if (field_num <= in->state.msg_state.last_field_num) return NULL;
+ if (in->state.msg_state.last_field_num + 1 != field_num) {
+ // Put skip.
+ UPB_ASSERT(field_num > in->state.msg_state.last_field_num);
+ uint32_t skip = field_num - in->state.msg_state.last_field_num;
+ ptr = upb_MtDataEncoder_PutBase92Varint(
+ e, ptr, skip, kUpb_EncodedValue_MinSkip, kUpb_EncodedValue_MaxSkip);
+ if (!ptr) return NULL;
+ }
+ in->state.msg_state.last_field_num = field_num;
+
+ uint32_t encoded_modifiers = 0;
+
+ // Put field type.
+ if (type == kUpb_FieldType_Enum &&
+ !(field_mod & kUpb_FieldModifier_IsClosedEnum)) {
+ type = kUpb_FieldType_Int32;
+ }
+
+ int encoded_type = kUpb_TypeToEncoded[type];
+ if (field_mod & kUpb_FieldModifier_IsRepeated) {
+ // Repeated fields shift the type number up (unlike other modifiers which
+ // are bit flags).
+ encoded_type += kUpb_EncodedType_RepeatedBase;
+
+ if (upb_IsTypePackable(type)) {
+ bool field_is_packed = field_mod & kUpb_FieldModifier_IsPacked;
+ bool default_is_packed = in->state.msg_state.msg_modifiers &
+ kUpb_MessageModifier_DefaultIsPacked;
+ if (field_is_packed != default_is_packed) {
+ encoded_modifiers |= kUpb_EncodedFieldModifier_FlipPacked;
+ }
+ }
+ }
+ ptr = upb_MtDataEncoder_Put(e, ptr, encoded_type);
+ if (!ptr) return NULL;
+
+ if (field_mod & kUpb_FieldModifier_IsProto3Singular) {
+ encoded_modifiers |= kUpb_EncodedFieldModifier_IsProto3Singular;
+ }
+ if (field_mod & kUpb_FieldModifier_IsRequired) {
+ encoded_modifiers |= kUpb_EncodedFieldModifier_IsRequired;
+ }
+ return upb_MtDataEncoder_PutModifier(e, ptr, encoded_modifiers);
+}
+
+char* upb_MtDataEncoder_StartOneof(upb_MtDataEncoder* e, char* ptr) {
+ upb_MtDataEncoderInternal* in = upb_MtDataEncoder_GetInternal(e, ptr);
+ if (in->state.msg_state.oneof_state == kUpb_OneofState_NotStarted) {
+ ptr = upb_MtDataEncoder_Put(e, ptr, upb_FromBase92(kUpb_EncodedValue_End));
+ } else {
+ ptr = upb_MtDataEncoder_Put(
+ e, ptr, upb_FromBase92(kUpb_EncodedValue_OneofSeparator));
+ }
+ in->state.msg_state.oneof_state = kUpb_OneofState_StartedOneof;
+ return ptr;
+}
+
+char* upb_MtDataEncoder_PutOneofField(upb_MtDataEncoder* e, char* ptr,
+ uint32_t field_num) {
+ upb_MtDataEncoderInternal* in = upb_MtDataEncoder_GetInternal(e, ptr);
+ if (in->state.msg_state.oneof_state == kUpb_OneofState_EmittedOneofField) {
+ ptr = upb_MtDataEncoder_Put(
+ e, ptr, upb_FromBase92(kUpb_EncodedValue_FieldSeparator));
+ if (!ptr) return NULL;
+ }
+ ptr = upb_MtDataEncoder_PutBase92Varint(e, ptr, field_num, upb_ToBase92(0),
+ upb_ToBase92(63));
+ in->state.msg_state.oneof_state = kUpb_OneofState_EmittedOneofField;
+ return ptr;
+}
+
+void upb_MtDataEncoder_StartEnum(upb_MtDataEncoder* e) {
+ upb_MtDataEncoderInternal* in = upb_MtDataEncoder_GetInternal(e, NULL);
+ in->state.enum_state.present_values_mask = 0;
+ in->state.enum_state.last_written_value = 0;
+}
+
+static char* upb_MtDataEncoder_FlushDenseEnumMask(upb_MtDataEncoder* e,
+ char* ptr) {
+ upb_MtDataEncoderInternal* in = (upb_MtDataEncoderInternal*)e->internal;
+ ptr = upb_MtDataEncoder_Put(e, ptr, in->state.enum_state.present_values_mask);
+ in->state.enum_state.present_values_mask = 0;
+ in->state.enum_state.last_written_value += 5;
+ return ptr;
+}
+
+char* upb_MtDataEncoder_PutEnumValue(upb_MtDataEncoder* e, char* ptr,
+ uint32_t val) {
+ // TODO(b/229641772): optimize this encoding.
+ upb_MtDataEncoderInternal* in = upb_MtDataEncoder_GetInternal(e, ptr);
+ UPB_ASSERT(val >= in->state.enum_state.last_written_value);
+ uint32_t delta = val - in->state.enum_state.last_written_value;
+ if (delta >= 5 && in->state.enum_state.present_values_mask) {
+ ptr = upb_MtDataEncoder_FlushDenseEnumMask(e, ptr);
+ if (!ptr) {
+ return NULL;
+ }
+ delta -= 5;
+ }
+
+ if (delta >= 5) {
+ ptr = upb_MtDataEncoder_PutBase92Varint(
+ e, ptr, delta, kUpb_EncodedValue_MinSkip, kUpb_EncodedValue_MaxSkip);
+ in->state.enum_state.last_written_value += delta;
+ delta = 0;
+ }
+
+ UPB_ASSERT((in->state.enum_state.present_values_mask >> delta) == 0);
+ in->state.enum_state.present_values_mask |= 1ULL << delta;
+ return ptr;
+}
+
+char* upb_MtDataEncoder_EndEnum(upb_MtDataEncoder* e, char* ptr) {
+ upb_MtDataEncoderInternal* in = upb_MtDataEncoder_GetInternal(e, ptr);
+ if (!in->state.enum_state.present_values_mask) return ptr;
+ return upb_MtDataEncoder_FlushDenseEnumMask(e, ptr);
+}
+
+const upb_MiniTable_Field* upb_MiniTable_FindFieldByNumber(
+ const upb_MiniTable* table, uint32_t number) {
+ int n = table->field_count;
+ for (int i = 0; i < n; i++) {
+ if (table->fields[i].number == number) {
+ return &table->fields[i];
+ }
+ }
+ return NULL;
+}
+
+/** Data decoder **************************************************************/
+
+// Note: we sort by this number when calculating layout order.
+typedef enum {
+ kUpb_LayoutItemType_OneofCase, // Oneof case.
+ kUpb_LayoutItemType_OneofField, // Oneof field data.
+ kUpb_LayoutItemType_Field, // Non-oneof field data.
+
+ kUpb_LayoutItemType_Max = kUpb_LayoutItemType_Field,
+} upb_LayoutItemType;
+
+#define kUpb_LayoutItem_IndexSentinel ((uint16_t)-1)
+
+typedef struct {
+ // Index of the corresponding field. When this is a oneof field, the field's
+ // offset will be the index of the next field in a linked list.
+ uint16_t field_index;
+ uint16_t offset;
+ upb_FieldRep rep;
+ upb_LayoutItemType type;
+} upb_LayoutItem;
+
+typedef struct {
+ upb_LayoutItem* data;
+ size_t size;
+ size_t capacity;
+} upb_LayoutItemVector;
+
+typedef struct {
+ const char* end;
+ upb_MiniTable* table;
+ upb_MiniTable_Field* fields;
+ upb_MiniTablePlatform platform;
+ upb_LayoutItemVector vec;
+ upb_Arena* arena;
+ upb_Status* status;
+
+ // When building enums.
+ upb_MiniTable_Enum* enum_table;
+ uint32_t enum_value_count;
+ uint32_t enum_data_count;
+ uint32_t enum_data_capacity;
+
+ jmp_buf err;
+} upb_MtDecoder;
+
+UPB_PRINTF(2, 3)
+UPB_NORETURN static void upb_MtDecoder_ErrorFormat(upb_MtDecoder* d,
+ const char* fmt, ...) {
+ va_list argp;
+ upb_Status_SetErrorMessage(d->status, "Error building mini table: ");
+ va_start(argp, fmt);
+ upb_Status_VAppendErrorFormat(d->status, fmt, argp);
+ va_end(argp);
+ UPB_LONGJMP(d->err, 1);
+}
+
+static void upb_MtDecoder_CheckOutOfMemory(upb_MtDecoder* d, const void* ptr) {
+ if (!ptr) upb_MtDecoder_ErrorFormat(d, "Out of memory");
+}
+
+// In each field's offset, we temporarily store a presence classifier:
+enum PresenceClass {
+ kNoPresence = 0,
+ kHasbitPresence = 1,
+ kRequiredPresence = 2,
+ kOneofBase = 3,
+ // Negative values refer to a specific oneof with that number. Positive
+ // values >= kOneofBase indicate that this field is in a oneof, and specify
+ // the next field in this oneof's linked list.
+};
+
+static const char* upb_MiniTable_DecodeBase92Varint(upb_MtDecoder* d,
+ const char* ptr,
+ char first_ch, uint8_t min,
+ uint8_t max,
+ uint32_t* out_val) {
+ uint32_t val = 0;
+ uint32_t shift = 0;
+ const int bits_per_char =
+ _upb_Log2Ceiling(upb_FromBase92(max) - upb_FromBase92(min));
+ char ch = first_ch;
+ while (1) {
+ uint32_t bits = upb_FromBase92(ch) - upb_FromBase92(min);
+ val |= bits << shift;
+ if (ptr == d->end || *ptr < min || max < *ptr) {
+ *out_val = val;
+ return ptr;
+ }
+ ch = *ptr++;
+ shift += bits_per_char;
+ if (shift >= 32) upb_MtDecoder_ErrorFormat(d, "Overlong varint");
+ }
+}
+
+static bool upb_MiniTable_HasSub(upb_MiniTable_Field* field,
+ uint64_t msg_modifiers) {
+ switch (field->descriptortype) {
+ case kUpb_FieldType_Message:
+ case kUpb_FieldType_Group:
+ case kUpb_FieldType_Enum:
+ return true;
+ case kUpb_FieldType_String:
+ if (!(msg_modifiers & kUpb_MessageModifier_ValidateUtf8)) {
+ field->descriptortype = kUpb_FieldType_Bytes;
+ }
+ return false;
+ default:
+ return false;
+ }
+}
+
+static bool upb_MtDecoder_FieldIsPackable(upb_MiniTable_Field* field) {
+ return (field->mode & kUpb_FieldMode_Array) &&
+ upb_IsTypePackable(field->descriptortype);
+}
+
+static void upb_MiniTable_SetTypeAndSub(upb_MiniTable_Field* field,
+ upb_FieldType type, uint32_t* sub_count,
+ uint64_t msg_modifiers) {
+ field->descriptortype = type;
+ if (upb_MiniTable_HasSub(field, msg_modifiers)) {
+ field->submsg_index = sub_count ? (*sub_count)++ : 0;
+ } else {
+ field->submsg_index = kUpb_NoSub;
+ }
+
+ if (upb_MtDecoder_FieldIsPackable(field) &&
+ (msg_modifiers & kUpb_MessageModifier_DefaultIsPacked)) {
+ field->mode |= kUpb_LabelFlags_IsPacked;
+ }
+}
+
+static void upb_MiniTable_SetField(upb_MtDecoder* d, uint8_t ch,
+ upb_MiniTable_Field* field,
+ uint64_t msg_modifiers,
+ uint32_t* sub_count) {
+ static const char kUpb_EncodedToFieldRep[] = {
+ [kUpb_EncodedType_Double] = kUpb_FieldRep_8Byte,
+ [kUpb_EncodedType_Float] = kUpb_FieldRep_4Byte,
+ [kUpb_EncodedType_Int64] = kUpb_FieldRep_8Byte,
+ [kUpb_EncodedType_UInt64] = kUpb_FieldRep_8Byte,
+ [kUpb_EncodedType_Int32] = kUpb_FieldRep_4Byte,
+ [kUpb_EncodedType_Fixed64] = kUpb_FieldRep_8Byte,
+ [kUpb_EncodedType_Fixed32] = kUpb_FieldRep_4Byte,
+ [kUpb_EncodedType_Bool] = kUpb_FieldRep_1Byte,
+ [kUpb_EncodedType_String] = kUpb_FieldRep_StringView,
+ [kUpb_EncodedType_Group] = kUpb_FieldRep_Pointer,
+ [kUpb_EncodedType_Message] = kUpb_FieldRep_Pointer,
+ [kUpb_EncodedType_Bytes] = kUpb_FieldRep_StringView,
+ [kUpb_EncodedType_UInt32] = kUpb_FieldRep_4Byte,
+ [kUpb_EncodedType_Enum] = kUpb_FieldRep_4Byte,
+ [kUpb_EncodedType_SFixed32] = kUpb_FieldRep_4Byte,
+ [kUpb_EncodedType_SFixed64] = kUpb_FieldRep_8Byte,
+ [kUpb_EncodedType_SInt32] = kUpb_FieldRep_4Byte,
+ [kUpb_EncodedType_SInt64] = kUpb_FieldRep_8Byte,
+ };
+
+ static const char kUpb_EncodedToType[] = {
+ [kUpb_EncodedType_Double] = kUpb_FieldType_Double,
+ [kUpb_EncodedType_Float] = kUpb_FieldType_Float,
+ [kUpb_EncodedType_Int64] = kUpb_FieldType_Int64,
+ [kUpb_EncodedType_UInt64] = kUpb_FieldType_UInt64,
+ [kUpb_EncodedType_Int32] = kUpb_FieldType_Int32,
+ [kUpb_EncodedType_Fixed64] = kUpb_FieldType_Fixed64,
+ [kUpb_EncodedType_Fixed32] = kUpb_FieldType_Fixed32,
+ [kUpb_EncodedType_Bool] = kUpb_FieldType_Bool,
+ [kUpb_EncodedType_String] = kUpb_FieldType_String,
+ [kUpb_EncodedType_Group] = kUpb_FieldType_Group,
+ [kUpb_EncodedType_Message] = kUpb_FieldType_Message,
+ [kUpb_EncodedType_Bytes] = kUpb_FieldType_Bytes,
+ [kUpb_EncodedType_UInt32] = kUpb_FieldType_UInt32,
+ [kUpb_EncodedType_Enum] = kUpb_FieldType_Enum,
+ [kUpb_EncodedType_SFixed32] = kUpb_FieldType_SFixed32,
+ [kUpb_EncodedType_SFixed64] = kUpb_FieldType_SFixed64,
+ [kUpb_EncodedType_SInt32] = kUpb_FieldType_SInt32,
+ [kUpb_EncodedType_SInt64] = kUpb_FieldType_SInt64,
+ };
+
+ int8_t type = upb_FromBase92(ch);
+ if (ch >= upb_ToBase92(kUpb_EncodedType_RepeatedBase)) {
+ type -= kUpb_EncodedType_RepeatedBase;
+ field->mode = kUpb_FieldMode_Array;
+ field->mode |= kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift;
+ field->offset = kNoPresence;
+ } else {
+ if (type >= sizeof(kUpb_EncodedToFieldRep)) {
+ upb_MtDecoder_ErrorFormat(d, "Invalid field type: %d", (int)type);
+ UPB_UNREACHABLE();
+ }
+ field->mode = kUpb_FieldMode_Scalar;
+ field->mode |= kUpb_EncodedToFieldRep[type] << kUpb_FieldRep_Shift;
+ field->offset = kHasbitPresence;
+ }
+ if (type >= sizeof(kUpb_EncodedToType)) {
+ upb_MtDecoder_ErrorFormat(d, "Invalid field type: %d", (int)type);
+ UPB_UNREACHABLE();
+ }
+ upb_MiniTable_SetTypeAndSub(field, kUpb_EncodedToType[type], sub_count,
+ msg_modifiers);
+}
+
+static void upb_MtDecoder_ModifyField(upb_MtDecoder* d,
+ uint32_t message_modifiers,
+ uint32_t field_modifiers,
+ upb_MiniTable_Field* field) {
+ if (field_modifiers & kUpb_EncodedFieldModifier_FlipPacked) {
+ if (!upb_MtDecoder_FieldIsPackable(field)) {
+ upb_MtDecoder_ErrorFormat(
+ d, "Cannot flip packed on unpackable field %" PRIu32, field->number);
+ UPB_UNREACHABLE();
+ }
+ field->mode ^= kUpb_LabelFlags_IsPacked;
+ }
+
+ bool singular = field_modifiers & kUpb_EncodedFieldModifier_IsProto3Singular;
+ bool required = field_modifiers & kUpb_EncodedFieldModifier_IsRequired;
+
+ // Validate.
+ if ((singular || required) && field->offset != kHasbitPresence) {
+ upb_MtDecoder_ErrorFormat(
+ d, "Invalid modifier(s) for repeated field %" PRIu32, field->number);
+ UPB_UNREACHABLE();
+ }
+ if (singular && required) {
+ upb_MtDecoder_ErrorFormat(
+ d, "Field %" PRIu32 " cannot be both singular and required",
+ field->number);
+ UPB_UNREACHABLE();
+ }
+
+ if (singular) field->offset = kNoPresence;
+ if (required) {
+ field->offset = kRequiredPresence;
+ }
+}
+
+static void upb_MtDecoder_PushItem(upb_MtDecoder* d, upb_LayoutItem item) {
+ if (d->vec.size == d->vec.capacity) {
+ size_t new_cap = UPB_MAX(8, d->vec.size * 2);
+ d->vec.data = realloc(d->vec.data, new_cap * sizeof(*d->vec.data));
+ upb_MtDecoder_CheckOutOfMemory(d, d->vec.data);
+ d->vec.capacity = new_cap;
+ }
+ d->vec.data[d->vec.size++] = item;
+}
+
+static void upb_MtDecoder_PushOneof(upb_MtDecoder* d, upb_LayoutItem item) {
+ if (item.field_index == kUpb_LayoutItem_IndexSentinel) {
+ upb_MtDecoder_ErrorFormat(d, "Empty oneof");
+ UPB_UNREACHABLE();
+ }
+ item.field_index -= kOneofBase;
+
+ // Push oneof data.
+ item.type = kUpb_LayoutItemType_OneofField;
+ upb_MtDecoder_PushItem(d, item);
+
+ // Push oneof case.
+ item.rep = kUpb_FieldRep_4Byte; // Field Number.
+ item.type = kUpb_LayoutItemType_OneofCase;
+ upb_MtDecoder_PushItem(d, item);
+}
+
+size_t upb_MtDecoder_SizeOfRep(upb_FieldRep rep,
+ upb_MiniTablePlatform platform) {
+ static const uint8_t kRepToSize32[] = {
+ [kUpb_FieldRep_1Byte] = 1, [kUpb_FieldRep_4Byte] = 4,
+ [kUpb_FieldRep_Pointer] = 4, [kUpb_FieldRep_StringView] = 8,
+ [kUpb_FieldRep_8Byte] = 8,
+ };
+ static const uint8_t kRepToSize64[] = {
+ [kUpb_FieldRep_1Byte] = 1, [kUpb_FieldRep_4Byte] = 4,
+ [kUpb_FieldRep_Pointer] = 8, [kUpb_FieldRep_StringView] = 16,
+ [kUpb_FieldRep_8Byte] = 8,
+ };
+ UPB_ASSERT(sizeof(upb_StringView) ==
+ UPB_SIZE(kRepToSize32, kRepToSize64)[kUpb_FieldRep_StringView]);
+ return platform == kUpb_MiniTablePlatform_32Bit ? kRepToSize32[rep]
+ : kRepToSize64[rep];
+}
+
+size_t upb_MtDecoder_AlignOfRep(upb_FieldRep rep,
+ upb_MiniTablePlatform platform) {
+ static const uint8_t kRepToAlign32[] = {
+ [kUpb_FieldRep_1Byte] = 1, [kUpb_FieldRep_4Byte] = 4,
+ [kUpb_FieldRep_Pointer] = 4, [kUpb_FieldRep_StringView] = 4,
+ [kUpb_FieldRep_8Byte] = 8,
+ };
+ static const uint8_t kRepToAlign64[] = {
+ [kUpb_FieldRep_1Byte] = 1, [kUpb_FieldRep_4Byte] = 4,
+ [kUpb_FieldRep_Pointer] = 8, [kUpb_FieldRep_StringView] = 8,
+ [kUpb_FieldRep_8Byte] = 8,
+ };
+ UPB_ASSERT(UPB_ALIGN_OF(upb_StringView) ==
+ UPB_SIZE(kRepToAlign32, kRepToAlign64)[kUpb_FieldRep_StringView]);
+ return platform == kUpb_MiniTablePlatform_32Bit ? kRepToAlign32[rep]
+ : kRepToAlign64[rep];
+}
+
+static const char* upb_MtDecoder_DecodeOneofField(upb_MtDecoder* d,
+ const char* ptr,
+ char first_ch,
+ upb_LayoutItem* item) {
+ uint32_t field_num;
+ ptr = upb_MiniTable_DecodeBase92Varint(
+ d, ptr, first_ch, kUpb_EncodedValue_MinOneofField,
+ kUpb_EncodedValue_MaxOneofField, &field_num);
+ upb_MiniTable_Field* f =
+ (void*)upb_MiniTable_FindFieldByNumber(d->table, field_num);
+
+ if (!f) {
+ upb_MtDecoder_ErrorFormat(d,
+ "Couldn't add field number %" PRIu32
+ " to oneof, no such field number.",
+ field_num);
+ UPB_UNREACHABLE();
+ }
+ if (f->offset != kHasbitPresence) {
+ upb_MtDecoder_ErrorFormat(
+ d,
+ "Cannot add repeated, required, or singular field %" PRIu32
+ " to oneof.",
+ field_num);
+ UPB_UNREACHABLE();
+ }
+
+ // Oneof storage must be large enough to accommodate the largest member.
+ int rep = f->mode >> kUpb_FieldRep_Shift;
+ if (upb_MtDecoder_SizeOfRep(rep, d->platform) >
+ upb_MtDecoder_SizeOfRep(item->rep, d->platform)) {
+ item->rep = rep;
+ }
+ // Prepend this field to the linked list.
+ f->offset = item->field_index;
+ item->field_index = (f - d->fields) + kOneofBase;
+ return ptr;
+}
+
+static const char* upb_MtDecoder_DecodeOneofs(upb_MtDecoder* d,
+ const char* ptr) {
+ upb_LayoutItem item = {.rep = 0,
+ .field_index = kUpb_LayoutItem_IndexSentinel};
+ while (ptr < d->end) {
+ char ch = *ptr++;
+ if (ch == kUpb_EncodedValue_FieldSeparator) {
+ // Field separator, no action needed.
+ } else if (ch == kUpb_EncodedValue_OneofSeparator) {
+ // End of oneof.
+ upb_MtDecoder_PushOneof(d, item);
+ item.field_index = kUpb_LayoutItem_IndexSentinel; // Move to next oneof.
+ } else {
+ ptr = upb_MtDecoder_DecodeOneofField(d, ptr, ch, &item);
+ }
+ }
+
+ // Push final oneof.
+ upb_MtDecoder_PushOneof(d, item);
+ return ptr;
+}
+
+static const char* upb_MtDecoder_ParseModifier(upb_MtDecoder* d,
+ const char* ptr, char first_ch,
+ upb_MiniTable_Field* last_field,
+ uint64_t* msg_modifiers) {
+ uint32_t mod;
+ ptr = upb_MiniTable_DecodeBase92Varint(d, ptr, first_ch,
+ kUpb_EncodedValue_MinModifier,
+ kUpb_EncodedValue_MaxModifier, &mod);
+ if (last_field) {
+ upb_MtDecoder_ModifyField(d, *msg_modifiers, mod, last_field);
+ } else {
+ if (!d->table) {
+ upb_MtDecoder_ErrorFormat(d, "Extensions cannot have message modifiers");
+ UPB_UNREACHABLE();
+ }
+ *msg_modifiers = mod;
+ }
+
+ return ptr;
+}
+
+static void upb_MtDecoder_AllocateSubs(upb_MtDecoder* d, uint32_t sub_count) {
+ size_t subs_bytes = sizeof(*d->table->subs) * sub_count;
+ d->table->subs = upb_Arena_Malloc(d->arena, subs_bytes);
+ upb_MtDecoder_CheckOutOfMemory(d, d->table->subs);
+}
+
+static const char* upb_MtDecoder_Parse(upb_MtDecoder* d, const char* ptr,
+ size_t len, void* fields,
+ size_t field_size, uint16_t* field_count,
+ uint32_t* sub_count) {
+ uint64_t msg_modifiers = 0;
+ uint32_t last_field_number = 0;
+ upb_MiniTable_Field* last_field = NULL;
+ bool need_dense_below = d->table != NULL;
+
+ d->end = UPB_PTRADD(ptr, len);
+
+ while (ptr < d->end) {
+ char ch = *ptr++;
+ if (ch <= kUpb_EncodedValue_MaxField) {
+ if (!d->table && last_field) {
+ // For extensions, consume only a single field and then return.
+ return --ptr;
+ }
+ upb_MiniTable_Field* field = fields;
+ *field_count += 1;
+ fields = (char*)fields + field_size;
+ field->number = ++last_field_number;
+ last_field = field;
+ upb_MiniTable_SetField(d, ch, field, msg_modifiers, sub_count);
+ } else if (kUpb_EncodedValue_MinModifier <= ch &&
+ ch <= kUpb_EncodedValue_MaxModifier) {
+ ptr = upb_MtDecoder_ParseModifier(d, ptr, ch, last_field, &msg_modifiers);
+ if (msg_modifiers & kUpb_MessageModifier_IsExtendable) {
+ d->table->ext |= kUpb_ExtMode_Extendable;
+ }
+ } else if (ch == kUpb_EncodedValue_End) {
+ if (!d->table) {
+ upb_MtDecoder_ErrorFormat(d, "Extensions cannot have oneofs.");
+ UPB_UNREACHABLE();
+ }
+ ptr = upb_MtDecoder_DecodeOneofs(d, ptr);
+ } else if (kUpb_EncodedValue_MinSkip <= ch &&
+ ch <= kUpb_EncodedValue_MaxSkip) {
+ if (need_dense_below) {
+ d->table->dense_below = d->table->field_count;
+ need_dense_below = false;
+ }
+ uint32_t skip;
+ ptr = upb_MiniTable_DecodeBase92Varint(d, ptr, ch,
+ kUpb_EncodedValue_MinSkip,
+ kUpb_EncodedValue_MaxSkip, &skip);
+ last_field_number += skip;
+ last_field_number--; // Next field seen will increment.
+ }
+ }
+
+ if (need_dense_below) {
+ d->table->dense_below = d->table->field_count;
+ }
+
+ return ptr;
+}
+
+static void upb_MtDecoder_ParseMessage(upb_MtDecoder* d, const char* data,
+ size_t len) {
+ // Buffer length is an upper bound on the number of fields. We will return
+ // what we don't use.
+ d->fields = upb_Arena_Malloc(d->arena, sizeof(*d->fields) * len);
+ upb_MtDecoder_CheckOutOfMemory(d, d->fields);
+
+ uint32_t sub_count = 0;
+ d->table->field_count = 0;
+ d->table->fields = d->fields;
+ upb_MtDecoder_Parse(d, data, len, d->fields, sizeof(*d->fields),
+ &d->table->field_count, &sub_count);
+
+ upb_Arena_ShrinkLast(d->arena, d->fields, sizeof(*d->fields) * len,
+ sizeof(*d->fields) * d->table->field_count);
+ d->table->fields = d->fields;
+ upb_MtDecoder_AllocateSubs(d, sub_count);
+}
+
+int upb_MtDecoder_CompareFields(const void* _a, const void* _b) {
+ const upb_LayoutItem* a = _a;
+ const upb_LayoutItem* b = _b;
+ // Currently we just sort by:
+ // 1. rep (smallest fields first)
+ // 2. type (oneof cases first)
+ // 2. field_index (smallest numbers first)
+ // The main goal of this is to reduce space lost to padding.
+ // Later we may have more subtle reasons to prefer a different ordering.
+ const int rep_bits = _upb_Log2Ceiling(kUpb_FieldRep_Max);
+ const int type_bits = _upb_Log2Ceiling(kUpb_LayoutItemType_Max);
+ const int idx_bits = (sizeof(a->field_index) * 8);
+ UPB_ASSERT(idx_bits + rep_bits + type_bits < 32);
+#define UPB_COMBINE(rep, ty, idx) (((rep << type_bits) | ty) << idx_bits) | idx
+ uint32_t a_packed = UPB_COMBINE(a->rep, a->type, a->field_index);
+ uint32_t b_packed = UPB_COMBINE(b->rep, b->type, b->field_index);
+ assert(a_packed != b_packed);
+#undef UPB_COMBINE
+ return a_packed < b_packed ? -1 : 1;
+}
+
+static bool upb_MtDecoder_SortLayoutItems(upb_MtDecoder* d) {
+ // Add items for all non-oneof fields (oneofs were already added).
+ int n = d->table->field_count;
+ for (int i = 0; i < n; i++) {
+ upb_MiniTable_Field* f = &d->fields[i];
+ if (f->offset >= kOneofBase) continue;
+ upb_LayoutItem item = {.field_index = i,
+ .rep = f->mode >> kUpb_FieldRep_Shift,
+ .type = kUpb_LayoutItemType_Field};
+ upb_MtDecoder_PushItem(d, item);
+ }
+
+ if (d->vec.size) {
+ qsort(d->vec.data, d->vec.size, sizeof(*d->vec.data),
+ upb_MtDecoder_CompareFields);
+ }
+
+ return true;
+}
+
+static size_t upb_MiniTable_DivideRoundUp(size_t n, size_t d) {
+ return (n + d - 1) / d;
+}
+
+static void upb_MtDecoder_AssignHasbits(upb_MiniTable* ret) {
+ int n = ret->field_count;
+ int last_hasbit = 0; // 0 cannot be used.
+
+ // First assign required fields, which must have the lowest hasbits.
+ for (int i = 0; i < n; i++) {
+ upb_MiniTable_Field* field = (upb_MiniTable_Field*)&ret->fields[i];
+ if (field->offset == kRequiredPresence) {
+ field->presence = ++last_hasbit;
+ } else if (field->offset == kNoPresence) {
+ field->presence = 0;
+ }
+ }
+ ret->required_count = last_hasbit;
+
+ // Next assign non-required hasbit fields.
+ for (int i = 0; i < n; i++) {
+ upb_MiniTable_Field* field = (upb_MiniTable_Field*)&ret->fields[i];
+ if (field->offset == kHasbitPresence) {
+ field->presence = ++last_hasbit;
+ }
+ }
+
+ ret->size = last_hasbit ? upb_MiniTable_DivideRoundUp(last_hasbit + 1, 8) : 0;
+}
+
+size_t upb_MtDecoder_Place(upb_MtDecoder* d, upb_FieldRep rep) {
+ size_t size = upb_MtDecoder_SizeOfRep(rep, d->platform);
+ size_t align = upb_MtDecoder_AlignOfRep(rep, d->platform);
+ size_t ret = UPB_ALIGN_UP(d->table->size, align);
+ static const size_t max = UINT16_MAX;
+ size_t new_size = ret + size;
+ if (new_size > max) {
+ upb_MtDecoder_ErrorFormat(
+ d, "Message size exceeded maximum size of %zu bytes", max);
+ }
+ d->table->size = new_size;
+ return ret;
+}
+
+static void upb_MtDecoder_AssignOffsets(upb_MtDecoder* d) {
+ upb_LayoutItem* end = UPB_PTRADD(d->vec.data, d->vec.size);
+
+ // Compute offsets.
+ for (upb_LayoutItem* item = d->vec.data; item < end; item++) {
+ item->offset = upb_MtDecoder_Place(d, item->rep);
+ }
+
+ // Assign oneof case offsets. We must do these first, since assigning
+ // actual offsets will overwrite the links of the linked list.
+ for (upb_LayoutItem* item = d->vec.data; item < end; item++) {
+ if (item->type != kUpb_LayoutItemType_OneofCase) continue;
+ upb_MiniTable_Field* f = &d->fields[item->field_index];
+ while (true) {
+ f->presence = ~item->offset;
+ if (f->offset == kUpb_LayoutItem_IndexSentinel) break;
+ UPB_ASSERT(f->offset - kOneofBase < d->table->field_count);
+ f = &d->fields[f->offset - kOneofBase];
+ }
+ }
+
+ // Assign offsets.
+ for (upb_LayoutItem* item = d->vec.data; item < end; item++) {
+ upb_MiniTable_Field* f = &d->fields[item->field_index];
+ switch (item->type) {
+ case kUpb_LayoutItemType_OneofField:
+ while (true) {
+ uint16_t next_offset = f->offset;
+ f->offset = item->offset;
+ if (next_offset == kUpb_LayoutItem_IndexSentinel) break;
+ f = &d->fields[next_offset - kOneofBase];
+ }
+ break;
+ case kUpb_LayoutItemType_Field:
+ f->offset = item->offset;
+ break;
+ default:
+ break;
+ }
+ }
+
+ // The fasttable parser (supported on 64-bit only) depends on this being a
+ // multiple of 8 in order to satisfy UPB_MALLOC_ALIGN, which is also 8.
+ //
+ // On 32-bit we could potentially make this smaller, but there is no
+ // compelling reason to optimize this right now.
+ d->table->size = UPB_ALIGN_UP(d->table->size, 8);
+}
+
+upb_MiniTable* upb_MiniTable_BuildWithBuf(const char* data, size_t len,
+ upb_MiniTablePlatform platform,
+ upb_Arena* arena, void** buf,
+ size_t* buf_size,
+ upb_Status* status) {
+ upb_MtDecoder decoder = {
+ .platform = platform,
+ .vec =
+ {
+ .data = *buf,
+ .capacity = *buf_size / sizeof(*decoder.vec.data),
+ .size = 0,
+ },
+ .arena = arena,
+ .status = status,
+ .table = upb_Arena_Malloc(arena, sizeof(*decoder.table)),
+ };
+
+ if (UPB_SETJMP(decoder.err)) {
+ decoder.table = NULL;
+ goto done;
+ }
+
+ upb_MtDecoder_CheckOutOfMemory(&decoder, decoder.table);
+
+ decoder.table->size = 0;
+ decoder.table->field_count = 0;
+ decoder.table->ext = kUpb_ExtMode_NonExtendable;
+ decoder.table->dense_below = 0;
+ decoder.table->table_mask = -1;
+ decoder.table->required_count = 0;
+
+ upb_MtDecoder_ParseMessage(&decoder, data, len);
+ upb_MtDecoder_AssignHasbits(decoder.table);
+ upb_MtDecoder_SortLayoutItems(&decoder);
+ upb_MtDecoder_AssignOffsets(&decoder);
+
+done:
+ *buf = decoder.vec.data;
+ *buf_size = decoder.vec.capacity * sizeof(*decoder.vec.data);
+ return decoder.table;
+}
+
+upb_MiniTable* upb_MiniTable_BuildMessageSet(upb_MiniTablePlatform platform,
+ upb_Arena* arena) {
+ upb_MiniTable* ret = upb_Arena_Malloc(arena, sizeof(*ret));
+ if (!ret) return NULL;
+
+ ret->size = 0;
+ ret->field_count = 0;
+ ret->ext = kUpb_ExtMode_IsMessageSet;
+ ret->dense_below = 0;
+ ret->table_mask = -1;
+ ret->required_count = 0;
+ return ret;
+}
+
+upb_MiniTable* upb_MiniTable_BuildMapEntry(upb_FieldType key_type,
+ upb_FieldType value_type,
+ bool value_is_proto3_enum,
+ upb_MiniTablePlatform platform,
+ upb_Arena* arena) {
+ upb_MiniTable* ret = upb_Arena_Malloc(arena, sizeof(*ret));
+ upb_MiniTable_Field* fields = upb_Arena_Malloc(arena, sizeof(*fields) * 2);
+ if (!ret || !fields) return NULL;
+
+ upb_MiniTable_Sub* subs = NULL;
+ if (value_is_proto3_enum) value_type = kUpb_FieldType_Int32;
+ if (value_type == kUpb_FieldType_Message ||
+ value_type == kUpb_FieldType_Group || value_type == kUpb_FieldType_Enum) {
+ subs = upb_Arena_Malloc(arena, sizeof(*subs));
+ if (!subs) return NULL;
+ }
+
+ size_t field_size =
+ upb_MtDecoder_SizeOfRep(kUpb_FieldRep_StringView, platform);
+
+ fields[0].number = 1;
+ fields[1].number = 2;
+ fields[0].mode = kUpb_FieldMode_Scalar;
+ fields[1].mode = kUpb_FieldMode_Scalar;
+ fields[0].presence = 0;
+ fields[1].presence = 0;
+ fields[0].offset = 0;
+ fields[1].offset = field_size;
+
+ upb_MiniTable_SetTypeAndSub(&fields[0], key_type, NULL, 0);
+ upb_MiniTable_SetTypeAndSub(&fields[1], value_type, NULL, 0);
+
+ ret->size = UPB_ALIGN_UP(2 * field_size, 8);
+ ret->field_count = 2;
+ ret->ext = kUpb_ExtMode_NonExtendable | kUpb_ExtMode_IsMapEntry;
+ ret->dense_below = 2;
+ ret->table_mask = -1;
+ ret->required_count = 0;
+ ret->subs = subs;
+ ret->fields = fields;
+ return ret;
+}
+
+static size_t upb_MiniTable_EnumSize(size_t count) {
+ return sizeof(upb_MiniTable_Enum) + count * sizeof(uint32_t);
+}
+
+static upb_MiniTable_Enum* _upb_MiniTable_AddEnumDataMember(upb_MtDecoder* d,
+ uint32_t val) {
+ if (d->enum_data_count == d->enum_data_capacity) {
+ size_t old_sz = upb_MiniTable_EnumSize(d->enum_data_capacity);
+ d->enum_data_capacity = UPB_MAX(2, d->enum_data_capacity * 2);
+ size_t new_sz = upb_MiniTable_EnumSize(d->enum_data_capacity);
+ d->enum_table = upb_Arena_Realloc(d->arena, d->enum_table, old_sz, new_sz);
+ upb_MtDecoder_CheckOutOfMemory(d, d->enum_table);
+ }
+ d->enum_table->data[d->enum_data_count++] = val;
+ return d->enum_table;
+}
+
+static void upb_MiniTable_BuildEnumValue(upb_MtDecoder* d, uint32_t val) {
+ upb_MiniTable_Enum* table = d->enum_table;
+ d->enum_value_count++;
+ if (table->value_count || (val > 512 && d->enum_value_count < val / 32)) {
+ if (table->value_count == 0) {
+ assert(d->enum_data_count == table->mask_limit / 32);
+ }
+ table = _upb_MiniTable_AddEnumDataMember(d, val);
+ table->value_count++;
+ } else {
+ uint32_t new_mask_limit = ((val / 32) + 1) * 32;
+ while (table->mask_limit < new_mask_limit) {
+ table = _upb_MiniTable_AddEnumDataMember(d, 0);
+ table->mask_limit += 32;
+ }
+ table->data[val / 32] |= 1ULL << (val % 32);
+ }
+}
+
+upb_MiniTable_Enum* upb_MiniTable_BuildEnum(const char* data, size_t len,
+ upb_Arena* arena,
+ upb_Status* status) {
+ upb_MtDecoder d = {
+ .enum_table = upb_Arena_Malloc(arena, upb_MiniTable_EnumSize(2)),
+ .enum_value_count = 0,
+ .enum_data_count = 0,
+ .enum_data_capacity = 1,
+ .status = status,
+ .end = UPB_PTRADD(data, len),
+ .arena = arena,
+ };
+
+ if (UPB_SETJMP(d.err)) {
+ return NULL;
+ }
+
+ upb_MtDecoder_CheckOutOfMemory(&d, d.enum_table);
+
+ // Guarantee at least 64 bits of mask without checking mask size.
+ d.enum_table->mask_limit = 64;
+ d.enum_table = _upb_MiniTable_AddEnumDataMember(&d, 0);
+ d.enum_table = _upb_MiniTable_AddEnumDataMember(&d, 0);
+
+ d.enum_table->value_count = 0;
+
+ const char* ptr = data;
+ uint32_t base = 0;
+
+ while (ptr < d.end) {
+ char ch = *ptr++;
+ if (ch <= kUpb_EncodedValue_MaxEnumMask) {
+ uint32_t mask = upb_FromBase92(ch);
+ for (int i = 0; i < 5; i++, base++, mask >>= 1) {
+ if (mask & 1) upb_MiniTable_BuildEnumValue(&d, base);
+ }
+ } else if (kUpb_EncodedValue_MinSkip <= ch &&
+ ch <= kUpb_EncodedValue_MaxSkip) {
+ uint32_t skip;
+ ptr = upb_MiniTable_DecodeBase92Varint(&d, ptr, ch,
+ kUpb_EncodedValue_MinSkip,
+ kUpb_EncodedValue_MaxSkip, &skip);
+ base += skip;
+ } else {
+ upb_Status_SetErrorFormat(status, "Unexpected character: %c", ch);
+ return NULL;
+ }
+ }
+
+ return d.enum_table;
+}
+
+const char* upb_MiniTable_BuildExtension(const char* data, size_t len,
+ upb_MiniTable_Extension* ext,
+ const upb_MiniTable* extendee,
+ upb_MiniTable_Sub sub,
+ upb_Status* status) {
+ upb_MtDecoder decoder = {
+ .arena = NULL,
+ .status = status,
+ .table = NULL,
+ };
+
+ if (UPB_SETJMP(decoder.err)) {
+ return NULL;
+ }
+
+ uint16_t count = 0;
+ const char* ret =
+ upb_MtDecoder_Parse(&decoder, data, len, ext, sizeof(*ext), &count, NULL);
+ if (!ret || count != 1) return NULL;
+
+ upb_MiniTable_Field* f = &ext->field;
+
+ f->mode |= kUpb_LabelFlags_IsExtension;
+ f->offset = 0;
+ f->presence = 0;
+
+ if (extendee->ext & kUpb_ExtMode_IsMessageSet) {
+ // Extensions of MessageSet must be messages.
+ if (!upb_IsSubMessage(f)) return NULL;
+
+ // Extensions of MessageSet must be non-repeating.
+ if ((f->mode & kUpb_FieldMode_Mask) == kUpb_FieldMode_Array) return NULL;
+ }
+
+ ext->extendee = extendee;
+ ext->sub = sub;
+
+ return ret;
+}
+
+upb_MiniTable* upb_MiniTable_Build(const char* data, size_t len,
+ upb_MiniTablePlatform platform,
+ upb_Arena* arena, upb_Status* status) {
+ void* buf = NULL;
+ size_t size = 0;
+ upb_MiniTable* ret = upb_MiniTable_BuildWithBuf(data, len, platform, arena,
+ &buf, &size, status);
+ free(buf);
+ return ret;
+}
+
+void upb_MiniTable_SetSubMessage(upb_MiniTable* table,
+ upb_MiniTable_Field* field,
+ const upb_MiniTable* sub) {
+ UPB_ASSERT((uintptr_t)table->fields <= (uintptr_t)field &&
+ (uintptr_t)field <
+ (uintptr_t)(table->fields + table->field_count));
+ if (sub->ext & kUpb_ExtMode_IsMapEntry) {
+ field->mode =
+ (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift) | kUpb_FieldMode_Map;
+ }
+ upb_MiniTable_Sub* table_sub = (void*)&table->subs[field->submsg_index];
+ table_sub->submsg = sub;
+}
+
+void upb_MiniTable_SetSubEnum(upb_MiniTable* table, upb_MiniTable_Field* field,
+ const upb_MiniTable_Enum* sub) {
+ UPB_ASSERT((uintptr_t)table->fields <= (uintptr_t)field &&
+ (uintptr_t)field <
+ (uintptr_t)(table->fields + table->field_count));
+ upb_MiniTable_Sub* table_sub = (void*)&table->subs[field->submsg_index];
+ table_sub->subenum = sub;
+}
+
+
+#include <string.h>
+
+
+// Must be last.
+
+/* The upb core does not generally have a concept of default instances. However
+ * for descriptor options we make an exception since the max size is known and
+ * modest (<200 bytes). All types can share a default instance since it is
+ * initialized to zeroes.
+ *
+ * We have to allocate an extra pointer for upb's internal metadata. */
+static const char opt_default_buf[_UPB_MAXOPT_SIZE + sizeof(void*)] = {0};
+const char* kUpbDefOptDefault = &opt_default_buf[sizeof(void*)];
+
+const char* _upb_DefBuilder_FullToShort(const char* fullname) {
+ const char* p;
+
+ if (fullname == NULL) {
+ return NULL;
+ } else if ((p = strrchr(fullname, '.')) == NULL) {
+ /* No '.' in the name, return the full string. */
+ return fullname;
+ } else {
+ /* Return one past the last '.'. */
+ return p + 1;
+ }
+}
+
+void _upb_DefBuilder_FailJmp(upb_DefBuilder* ctx) { UPB_LONGJMP(ctx->err, 1); }
+
+void _upb_DefBuilder_Errf(upb_DefBuilder* ctx, const char* fmt, ...) {
+ va_list argp;
+ va_start(argp, fmt);
+ upb_Status_VSetErrorFormat(ctx->status, fmt, argp);
+ va_end(argp);
+ _upb_DefBuilder_FailJmp(ctx);
+}
+
+void _upb_DefBuilder_OomErr(upb_DefBuilder* ctx) {
+ upb_Status_SetErrorMessage(ctx->status, "out of memory");
+ _upb_DefBuilder_FailJmp(ctx);
+}
+
+const char* _upb_DefBuilder_MakeFullName(upb_DefBuilder* ctx,
+ const char* prefix,
+ upb_StringView name) {
+ if (prefix) {
+ // ret = prefix + '.' + name;
+ size_t n = strlen(prefix);
+ char* ret = _upb_DefBuilder_Alloc(ctx, n + name.size + 2);
+ strcpy(ret, prefix);
+ ret[n] = '.';
+ memcpy(&ret[n + 1], name.data, name.size);
+ ret[n + 1 + name.size] = '\0';
+ return ret;
+ } else {
+ char* ret = upb_strdup2(name.data, name.size, ctx->arena);
+ if (!ret) _upb_DefBuilder_OomErr(ctx);
+ return ret;
+ }
+}
+
+static bool remove_component(char* base, size_t* len) {
+ if (*len == 0) return false;
+
+ for (size_t i = *len - 1; i > 0; i--) {
+ if (base[i] == '.') {
+ *len = i;
+ return true;
+ }
+ }
+
+ *len = 0;
+ return true;
+}
+
+const void* _upb_DefBuilder_ResolveAny(upb_DefBuilder* ctx,
+ const char* from_name_dbg,
+ const char* base, upb_StringView sym,
+ upb_deftype_t* type) {
+ if (sym.size == 0) goto notfound;
+ upb_value v;
+ if (sym.data[0] == '.') {
+ /* Symbols starting with '.' are absolute, so we do a single lookup.
+ * Slice to omit the leading '.' */
+ if (!_upb_DefPool_LookupSym(ctx->symtab, sym.data + 1, sym.size - 1, &v)) {
+ goto notfound;
+ }
+ } else {
+ /* Remove components from base until we find an entry or run out. */
+ size_t baselen = base ? strlen(base) : 0;
+ char* tmp = malloc(sym.size + baselen + 1);
+ while (1) {
+ char* p = tmp;
+ if (baselen) {
+ memcpy(p, base, baselen);
+ p[baselen] = '.';
+ p += baselen + 1;
+ }
+ memcpy(p, sym.data, sym.size);
+ p += sym.size;
+ if (_upb_DefPool_LookupSym(ctx->symtab, tmp, p - tmp, &v)) {
+ break;
+ }
+ if (!remove_component(tmp, &baselen)) {
+ free(tmp);
+ goto notfound;
+ }
+ }
+ free(tmp);
+ }
+
+ *type = _upb_DefType_Type(v);
+ return _upb_DefType_Unpack(v, *type);
+
+notfound:
+ _upb_DefBuilder_Errf(ctx, "couldn't resolve name '" UPB_STRINGVIEW_FORMAT "'",
+ UPB_STRINGVIEW_ARGS(sym));
+}
+
+const void* _upb_DefBuilder_Resolve(upb_DefBuilder* ctx,
+ const char* from_name_dbg, const char* base,
+ upb_StringView sym, upb_deftype_t type) {
+ upb_deftype_t found_type;
+ const void* ret =
+ _upb_DefBuilder_ResolveAny(ctx, from_name_dbg, base, sym, &found_type);
+ if (ret && found_type != type) {
+ _upb_DefBuilder_Errf(ctx,
+ "type mismatch when resolving %s: couldn't find "
+ "name " UPB_STRINGVIEW_FORMAT " with type=%d",
+ from_name_dbg, UPB_STRINGVIEW_ARGS(sym), (int)type);
+ }
+ return ret;
+}
+
+// Per ASCII this will lower-case a letter. If the result is a letter, the
+// input was definitely a letter. If the output is not a letter, this may
+// have transformed the character unpredictably.
+static char upb_ascii_lower(char ch) { return ch | 0x20; }
+
+// isalpha() etc. from <ctype.h> are locale-dependent, which we don't want.
+static bool upb_isbetween(uint8_t c, uint8_t low, uint8_t high) {
+ return low <= c && c <= high;
+}
+
+static bool upb_isletter(char c) {
+ char lower = upb_ascii_lower(c);
+ return upb_isbetween(lower, 'a', 'z') || c == '_';
+}
+
+static bool upb_isalphanum(char c) {
+ return upb_isletter(c) || upb_isbetween(c, '0', '9');
+}
+
+static bool TryGetChar(const char** src, const char* end, char* ch) {
+ if (*src == end) return false;
+ *ch = **src;
+ *src += 1;
+ return true;
+}
+
+static char TryGetHexDigit(const char** src, const char* end) {
+ char ch;
+ if (!TryGetChar(src, end, &ch)) return -1;
+ if ('0' <= ch && ch <= '9') {
+ return ch - '0';
+ }
+ ch = upb_ascii_lower(ch);
+ if ('a' <= ch && ch <= 'f') {
+ return ch - 'a' + 0xa;
+ }
+ *src -= 1; // Char wasn't actually a hex digit.
+ return -1;
+}
+
+static char upb_DefBuilder_ParseHexEscape(upb_DefBuilder* ctx,
+ const upb_FieldDef* f,
+ const char** src, const char* end) {
+ char hex_digit = TryGetHexDigit(src, end);
+ if (hex_digit < 0) {
+ _upb_DefBuilder_Errf(
+ ctx, "\\x cannot be followed by non-hex digit in field '%s' default",
+ upb_FieldDef_FullName(f));
+ return 0;
+ }
+ unsigned int ret = hex_digit;
+ while ((hex_digit = TryGetHexDigit(src, end)) >= 0) {
+ ret = (ret << 4) | hex_digit;
+ }
+ if (ret > 0xff) {
+ _upb_DefBuilder_Errf(ctx, "Value of hex escape in field %s exceeds 8 bits",
+ upb_FieldDef_FullName(f));
+ return 0;
+ }
+ return ret;
+}
+
+static char TryGetOctalDigit(const char** src, const char* end) {
+ char ch;
+ if (!TryGetChar(src, end, &ch)) return -1;
+ if ('0' <= ch && ch <= '7') {
+ return ch - '0';
+ }
+ *src -= 1; // Char wasn't actually an octal digit.
+ return -1;
+}
+
+static char upb_DefBuilder_ParseOctalEscape(upb_DefBuilder* ctx,
+ const upb_FieldDef* f,
+ const char** src, const char* end) {
+ char ch = 0;
+ for (int i = 0; i < 3; i++) {
+ char digit;
+ if ((digit = TryGetOctalDigit(src, end)) >= 0) {
+ ch = (ch << 3) | digit;
+ }
+ }
+ return ch;
+}
+
+char _upb_DefBuilder_ParseEscape(upb_DefBuilder* ctx, const upb_FieldDef* f,
+ const char** src, const char* end) {
+ char ch;
+ if (!TryGetChar(src, end, &ch)) {
+ _upb_DefBuilder_Errf(ctx, "unterminated escape sequence in field %s",
+ upb_FieldDef_FullName(f));
+ return 0;
+ }
+ switch (ch) {
+ case 'a':
+ return '\a';
+ case 'b':
+ return '\b';
+ case 'f':
+ return '\f';
+ case 'n':
+ return '\n';
+ case 'r':
+ return '\r';
+ case 't':
+ return '\t';
+ case 'v':
+ return '\v';
+ case '\\':
+ return '\\';
+ case '\'':
+ return '\'';
+ case '\"':
+ return '\"';
+ case '?':
+ return '\?';
+ case 'x':
+ case 'X':
+ return upb_DefBuilder_ParseHexEscape(ctx, f, src, end);
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ *src -= 1;
+ return upb_DefBuilder_ParseOctalEscape(ctx, f, src, end);
+ }
+ _upb_DefBuilder_Errf(ctx, "Unknown escape sequence: \\%c", ch);
+}
+
+void _upb_DefBuilder_CheckIdentSlow(upb_DefBuilder* ctx, upb_StringView name,
+ bool full) {
+ const char* str = name.data;
+ const size_t len = name.size;
+ bool start = true;
+ for (size_t i = 0; i < len; i++) {
+ const char c = str[i];
+ if (c == '.') {
+ if (start || !full) {
+ _upb_DefBuilder_Errf(
+ ctx, "invalid name: unexpected '.' (" UPB_STRINGVIEW_FORMAT ")",
+ UPB_STRINGVIEW_ARGS(name));
+ }
+ start = true;
+ } else if (start) {
+ if (!upb_isletter(c)) {
+ _upb_DefBuilder_Errf(ctx,
+ "invalid name: path components must start with a "
+ "letter (" UPB_STRINGVIEW_FORMAT ")",
+ UPB_STRINGVIEW_ARGS(name));
+ }
+ start = false;
+ } else if (!upb_isalphanum(c)) {
+ _upb_DefBuilder_Errf(
+ ctx,
+ "invalid name: non-alphanumeric character (" UPB_STRINGVIEW_FORMAT
+ ")",
+ UPB_STRINGVIEW_ARGS(name));
+ }
+ }
+ if (start) {
+ _upb_DefBuilder_Errf(ctx,
+ "invalid name: empty part (" UPB_STRINGVIEW_FORMAT ")",
+ UPB_STRINGVIEW_ARGS(name));
+ }
+
+ // We should never reach this point.
+ UPB_ASSERT(false);
+}
+
+
+
+// Must be last.
+
+struct upb_DefPool {
+ upb_Arena* arena;
+ upb_strtable syms; // full_name -> packed def ptr
+ upb_strtable files; // file_name -> (upb_FileDef*)
+ upb_inttable exts; // (upb_MiniTable_Extension*) -> (upb_FieldDef*)
+ upb_ExtensionRegistry* extreg;
+ void* scratch_data;
+ size_t scratch_size;
+ size_t bytes_loaded;
+};
+
+void upb_DefPool_Free(upb_DefPool* s) {
+ upb_Arena_Free(s->arena);
+ upb_gfree(s->scratch_data);
+ upb_gfree(s);
+}
+
+upb_DefPool* upb_DefPool_New(void) {
+ upb_DefPool* s = upb_gmalloc(sizeof(*s));
+ if (!s) return NULL;
+
+ s->arena = upb_Arena_New();
+ s->bytes_loaded = 0;
+
+ s->scratch_size = 240;
+ s->scratch_data = upb_gmalloc(s->scratch_size);
+ if (!s->scratch_data) goto err;
+
+ if (!upb_strtable_init(&s->syms, 32, s->arena)) goto err;
+ if (!upb_strtable_init(&s->files, 4, s->arena)) goto err;
+ if (!upb_inttable_init(&s->exts, s->arena)) goto err;
+
+ s->extreg = upb_ExtensionRegistry_New(s->arena);
+ if (!s->extreg) goto err;
+
+ return s;
+
+err:
+ upb_DefPool_Free(s);
+ return NULL;
+}
+
+bool _upb_DefPool_InsertExt(upb_DefPool* s, const upb_MiniTable_Extension* ext,
+ upb_FieldDef* f) {
+ return upb_inttable_insert(&s->exts, (uintptr_t)ext, upb_value_constptr(f),
+ s->arena);
+}
+
+bool _upb_DefPool_InsertSym(upb_DefPool* s, upb_StringView sym, upb_value v,
+ upb_Status* status) {
+ // TODO: table should support an operation "tryinsert" to avoid the double
+ // lookup.
+ if (upb_strtable_lookup2(&s->syms, sym.data, sym.size, NULL)) {
+ upb_Status_SetErrorFormat(status, "duplicate symbol '%s'", sym.data);
+ return false;
+ }
+ if (!upb_strtable_insert(&s->syms, sym.data, sym.size, v, s->arena)) {
+ upb_Status_SetErrorMessage(status, "out of memory");
+ return false;
+ }
+ return true;
+}
+
+static const void* _upb_DefPool_Unpack(const upb_DefPool* s, const char* sym,
+ size_t size, upb_deftype_t type) {
+ upb_value v;
+ return upb_strtable_lookup2(&s->syms, sym, size, &v)
+ ? _upb_DefType_Unpack(v, type)
+ : NULL;
+}
+
+bool _upb_DefPool_LookupSym(const upb_DefPool* s, const char* sym, size_t size,
+ upb_value* v) {
+ return upb_strtable_lookup2(&s->syms, sym, size, v);
+}
+
+upb_ExtensionRegistry* _upb_DefPool_ExtReg(const upb_DefPool* s) {
+ return s->extreg;
+}
+
+void** _upb_DefPool_ScratchData(const upb_DefPool* s) {
+ return (void**)&s->scratch_data;
+}
+
+size_t* _upb_DefPool_ScratchSize(const upb_DefPool* s) {
+ return (size_t*)&s->scratch_size;
+}
+
+const upb_MessageDef* upb_DefPool_FindMessageByName(const upb_DefPool* s,
+ const char* sym) {
+ return _upb_DefPool_Unpack(s, sym, strlen(sym), UPB_DEFTYPE_MSG);
+}
+
+const upb_MessageDef* upb_DefPool_FindMessageByNameWithSize(
+ const upb_DefPool* s, const char* sym, size_t len) {
+ return _upb_DefPool_Unpack(s, sym, len, UPB_DEFTYPE_MSG);
+}
+
+const upb_EnumDef* upb_DefPool_FindEnumByName(const upb_DefPool* s,
+ const char* sym) {
+ return _upb_DefPool_Unpack(s, sym, strlen(sym), UPB_DEFTYPE_ENUM);
+}
+
+const upb_EnumValueDef* upb_DefPool_FindEnumByNameval(const upb_DefPool* s,
+ const char* sym) {
+ return _upb_DefPool_Unpack(s, sym, strlen(sym), UPB_DEFTYPE_ENUMVAL);
+}
+
+const upb_FileDef* upb_DefPool_FindFileByName(const upb_DefPool* s,
+ const char* name) {
+ upb_value v;
+ return upb_strtable_lookup(&s->files, name, &v) ? upb_value_getconstptr(v)
+ : NULL;
+}
+
+const upb_FileDef* upb_DefPool_FindFileByNameWithSize(const upb_DefPool* s,
+ const char* name,
+ size_t len) {
+ upb_value v;
+ return upb_strtable_lookup2(&s->files, name, len, &v)
+ ? upb_value_getconstptr(v)
+ : NULL;
+}
+
+const upb_FieldDef* upb_DefPool_FindExtensionByNameWithSize(
+ const upb_DefPool* s, const char* name, size_t size) {
+ upb_value v;
+ if (!upb_strtable_lookup2(&s->syms, name, size, &v)) return NULL;
+
+ switch (_upb_DefType_Type(v)) {
+ case UPB_DEFTYPE_FIELD:
+ return _upb_DefType_Unpack(v, UPB_DEFTYPE_FIELD);
+ case UPB_DEFTYPE_MSG: {
+ const upb_MessageDef* m = _upb_DefType_Unpack(v, UPB_DEFTYPE_MSG);
+ return _upb_MessageDef_InMessageSet(m)
+ ? upb_MessageDef_NestedExtension(m, 0)
+ : NULL;
+ }
+ default:
+ break;
+ }
+
+ return NULL;
+}
+
+const upb_FieldDef* upb_DefPool_FindExtensionByName(const upb_DefPool* s,
+ const char* sym) {
+ return upb_DefPool_FindExtensionByNameWithSize(s, sym, strlen(sym));
+}
+
+const upb_ServiceDef* upb_DefPool_FindServiceByName(const upb_DefPool* s,
+ const char* name) {
+ return _upb_DefPool_Unpack(s, name, strlen(name), UPB_DEFTYPE_SERVICE);
+}
+
+const upb_ServiceDef* upb_DefPool_FindServiceByNameWithSize(
+ const upb_DefPool* s, const char* name, size_t size) {
+ return _upb_DefPool_Unpack(s, name, size, UPB_DEFTYPE_SERVICE);
+}
+
+const upb_FileDef* upb_DefPool_FindFileContainingSymbol(const upb_DefPool* s,
+ const char* name) {
+ upb_value v;
+ // TODO(haberman): non-extension fields and oneofs.
+ if (upb_strtable_lookup(&s->syms, name, &v)) {
+ switch (_upb_DefType_Type(v)) {
+ case UPB_DEFTYPE_EXT: {
+ const upb_FieldDef* f = _upb_DefType_Unpack(v, UPB_DEFTYPE_EXT);
+ return upb_FieldDef_File(f);
+ }
+ case UPB_DEFTYPE_MSG: {
+ const upb_MessageDef* m = _upb_DefType_Unpack(v, UPB_DEFTYPE_MSG);
+ return upb_MessageDef_File(m);
+ }
+ case UPB_DEFTYPE_ENUM: {
+ const upb_EnumDef* e = _upb_DefType_Unpack(v, UPB_DEFTYPE_ENUM);
+ return upb_EnumDef_File(e);
+ }
+ case UPB_DEFTYPE_ENUMVAL: {
+ const upb_EnumValueDef* ev =
+ _upb_DefType_Unpack(v, UPB_DEFTYPE_ENUMVAL);
+ return upb_EnumDef_File(upb_EnumValueDef_Enum(ev));
+ }
+ case UPB_DEFTYPE_SERVICE: {
+ const upb_ServiceDef* service =
+ _upb_DefType_Unpack(v, UPB_DEFTYPE_SERVICE);
+ return upb_ServiceDef_File(service);
+ }
+ default:
+ UPB_UNREACHABLE();
+ }
+ }
+
+ const char* last_dot = strrchr(name, '.');
+ if (last_dot) {
+ const upb_MessageDef* parent =
+ upb_DefPool_FindMessageByNameWithSize(s, name, last_dot - name);
+ if (parent) {
+ const char* shortname = last_dot + 1;
+ if (upb_MessageDef_FindByNameWithSize(parent, shortname,
+ strlen(shortname), NULL, NULL)) {
+ return upb_MessageDef_File(parent);
+ }
+ }
+ }
+
+ return NULL;
+}
+
+static void remove_filedef(upb_DefPool* s, upb_FileDef* file) {
+ intptr_t iter = UPB_INTTABLE_BEGIN;
+ upb_StringView key;
+ upb_value val;
+ while (upb_strtable_next2(&s->syms, &key, &val, &iter)) {
+ const upb_FileDef* f;
+ switch (_upb_DefType_Type(val)) {
+ case UPB_DEFTYPE_EXT:
+ f = upb_FieldDef_File(_upb_DefType_Unpack(val, UPB_DEFTYPE_EXT));
+ break;
+ case UPB_DEFTYPE_MSG:
+ f = upb_MessageDef_File(_upb_DefType_Unpack(val, UPB_DEFTYPE_MSG));
+ break;
+ case UPB_DEFTYPE_ENUM:
+ f = upb_EnumDef_File(_upb_DefType_Unpack(val, UPB_DEFTYPE_ENUM));
+ break;
+ case UPB_DEFTYPE_ENUMVAL:
+ f = upb_EnumDef_File(upb_EnumValueDef_Enum(
+ _upb_DefType_Unpack(val, UPB_DEFTYPE_ENUMVAL)));
+ break;
+ case UPB_DEFTYPE_SERVICE:
+ f = upb_ServiceDef_File(_upb_DefType_Unpack(val, UPB_DEFTYPE_SERVICE));
+ break;
+ default:
+ UPB_UNREACHABLE();
+ }
+
+ if (f == file) upb_strtable_removeiter(&s->syms, &iter);
+ }
+}
+
+static const upb_FileDef* _upb_DefPool_AddFile(
+ upb_DefPool* s, const google_protobuf_FileDescriptorProto* file_proto,
+ const upb_MiniTable_File* layout, upb_Status* status) {
+ const upb_StringView name = google_protobuf_FileDescriptorProto_name(file_proto);
+
+ if (name.size == 0) {
+ upb_Status_SetErrorFormat(status,
+ "missing name in google_protobuf_FileDescriptorProto");
+ return NULL;
+ }
+
+ // Determine whether we already know about this file.
+ {
+ upb_value v;
+ if (upb_strtable_lookup2(&s->files, name.data, name.size, &v)) {
+ upb_Status_SetErrorFormat(status,
+ "duplicate file name " UPB_STRINGVIEW_FORMAT,
+ UPB_STRINGVIEW_ARGS(name));
+ return NULL;
+ }
+ }
+
+ upb_DefBuilder ctx = {
+ .symtab = s,
+ .layout = layout,
+ .msg_count = 0,
+ .enum_count = 0,
+ .ext_count = 0,
+ .status = status,
+ .file = NULL,
+ .arena = upb_Arena_New(),
+ .tmp_arena = upb_Arena_New(),
+ };
+
+ if (UPB_SETJMP(ctx.err)) {
+ UPB_ASSERT(!upb_Status_IsOk(status));
+ if (ctx.file) {
+ remove_filedef(s, ctx.file);
+ ctx.file = NULL;
+ }
+ } else if (!ctx.arena || !ctx.tmp_arena) {
+ _upb_DefBuilder_OomErr(&ctx);
+ } else {
+ _upb_FileDef_Create(&ctx, file_proto);
+ upb_strtable_insert(&s->files, name.data, name.size,
+ upb_value_constptr(ctx.file), ctx.arena);
+ UPB_ASSERT(upb_Status_IsOk(status));
+ upb_Arena_Fuse(s->arena, ctx.arena);
+ }
+
+ if (ctx.arena) upb_Arena_Free(ctx.arena);
+ if (ctx.tmp_arena) upb_Arena_Free(ctx.tmp_arena);
+ return ctx.file;
+}
+
+const upb_FileDef* upb_DefPool_AddFile(
+ upb_DefPool* s, const google_protobuf_FileDescriptorProto* file_proto,
+ upb_Status* status) {
+ return _upb_DefPool_AddFile(s, file_proto, NULL, status);
+}
+
+/* Include here since we want most of this file to be stdio-free. */
+#include <stdio.h>
+
+bool _upb_DefPool_LoadDefInitEx(upb_DefPool* s, const _upb_DefPool_Init* init,
+ bool rebuild_minitable) {
+ /* Since this function should never fail (it would indicate a bug in upb) we
+ * print errors to stderr instead of returning error status to the user. */
+ _upb_DefPool_Init** deps = init->deps;
+ google_protobuf_FileDescriptorProto* file;
+ upb_Arena* arena;
+ upb_Status status;
+
+ upb_Status_Clear(&status);
+
+ if (upb_DefPool_FindFileByName(s, init->filename)) {
+ return true;
+ }
+
+ arena = upb_Arena_New();
+
+ for (; *deps; deps++) {
+ if (!_upb_DefPool_LoadDefInitEx(s, *deps, rebuild_minitable)) goto err;
+ }
+
+ file = google_protobuf_FileDescriptorProto_parse_ex(
+ init->descriptor.data, init->descriptor.size, NULL,
+ kUpb_DecodeOption_AliasString, arena);
+ s->bytes_loaded += init->descriptor.size;
+
+ if (!file) {
+ upb_Status_SetErrorFormat(
+ &status,
+ "Failed to parse compiled-in descriptor for file '%s'. This should "
+ "never happen.",
+ init->filename);
+ goto err;
+ }
+
+ const upb_MiniTable_File* mt = rebuild_minitable ? NULL : init->layout;
+ if (!_upb_DefPool_AddFile(s, file, mt, &status)) {
+ goto err;
+ }
+
+ upb_Arena_Free(arena);
+ return true;
+
+err:
+ fprintf(stderr,
+ "Error loading compiled-in descriptor for file '%s' (this should "
+ "never happen): %s\n",
+ init->filename, upb_Status_ErrorMessage(&status));
+ upb_Arena_Free(arena);
+ return false;
+}
+
+size_t _upb_DefPool_BytesLoaded(const upb_DefPool* s) {
+ return s->bytes_loaded;
+}
+
+upb_Arena* _upb_DefPool_Arena(const upb_DefPool* s) { return s->arena; }
+
+const upb_FieldDef* _upb_DefPool_FindExtensionByMiniTable(
+ const upb_DefPool* s, const upb_MiniTable_Extension* ext) {
+ upb_value v;
+ bool ok = upb_inttable_lookup(&s->exts, (uintptr_t)ext, &v);
+ UPB_ASSERT(ok);
+ return upb_value_getconstptr(v);
+}
+
+const upb_FieldDef* upb_DefPool_FindExtensionByNumber(const upb_DefPool* s,
+ const upb_MessageDef* m,
+ int32_t fieldnum) {
+ const upb_MiniTable* l = upb_MessageDef_MiniTable(m);
+ const upb_MiniTable_Extension* ext = _upb_extreg_get(s->extreg, l, fieldnum);
+ return ext ? _upb_DefPool_FindExtensionByMiniTable(s, ext) : NULL;
+}
+
+const upb_ExtensionRegistry* upb_DefPool_ExtensionRegistry(
+ const upb_DefPool* s) {
+ return s->extreg;
+}
+
+const upb_FieldDef** upb_DefPool_GetAllExtensions(const upb_DefPool* s,
+ const upb_MessageDef* m,
+ size_t* count) {
+ size_t n = 0;
+ intptr_t iter = UPB_INTTABLE_BEGIN;
+ uintptr_t key;
+ upb_value val;
+ // This is O(all exts) instead of O(exts for m). If we need this to be
+ // efficient we may need to make extreg into a two-level table, or have a
+ // second per-message index.
+ while (upb_inttable_next2(&s->exts, &key, &val, &iter)) {
+ const upb_FieldDef* f = upb_value_getconstptr(val);
+ if (upb_FieldDef_ContainingType(f) == m) n++;
+ }
+ const upb_FieldDef** exts = malloc(n * sizeof(*exts));
+ iter = UPB_INTTABLE_BEGIN;
+ size_t i = 0;
+ while (upb_inttable_next2(&s->exts, &key, &val, &iter)) {
+ const upb_FieldDef* f = upb_value_getconstptr(val);
+ if (upb_FieldDef_ContainingType(f) == m) exts[i++] = f;
+ }
+ *count = n;
+ return exts;
+}
+
+bool _upb_DefPool_LoadDefInit(upb_DefPool* s, const _upb_DefPool_Init* init) {
+ return _upb_DefPool_LoadDefInitEx(s, init, false);
+}
+
+
+// Must be last.
+
+upb_deftype_t _upb_DefType_Type(upb_value v) {
+ const uintptr_t num = (uintptr_t)upb_value_getconstptr(v);
+ return num & UPB_DEFTYPE_MASK;
+}
+
+upb_value _upb_DefType_Pack(const void* ptr, upb_deftype_t type) {
+ uintptr_t num = (uintptr_t)ptr;
+ UPB_ASSERT((num & UPB_DEFTYPE_MASK) == 0);
+ num |= type;
+ return upb_value_constptr((const void*)num);
+}
+
+const void* _upb_DefType_Unpack(upb_value v, upb_deftype_t type) {
+ uintptr_t num = (uintptr_t)upb_value_getconstptr(v);
+ return (num & UPB_DEFTYPE_MASK) == type
+ ? (const void*)(num & ~UPB_DEFTYPE_MASK)
+ : NULL;
+}
+
+
+// Must be last.
+
+bool _upb_DescState_Grow(upb_DescState* d, upb_Arena* a) {
+ const size_t oldbufsize = d->bufsize;
+ const int used = d->ptr - d->buf;
+
+ if (!d->buf) {
+ d->buf = upb_Arena_Malloc(a, d->bufsize);
+ if (!d->buf) return false;
+ d->ptr = d->buf;
+ d->e.end = d->buf + d->bufsize;
+ }
+
+ if (oldbufsize - used < kUpb_MtDataEncoder_MinSize) {
+ d->bufsize *= 2;
+ d->buf = upb_Arena_Realloc(a, d->buf, oldbufsize, d->bufsize);
+ if (!d->buf) return false;
+ d->ptr = d->buf + used;
+ d->e.end = d->buf + d->bufsize;
+ }
+
+ return true;
+}
+
+
+#include <stdio.h>
+
+
+// Must be last.
+
+struct upb_EnumDef {
+ const google_protobuf_EnumOptions* opts;
+ const upb_MiniTable_Enum* layout; // Only for proto2.
+ const upb_FileDef* file;
+ const upb_MessageDef* containing_type; // Could be merged with "file".
+ const char* full_name;
+ upb_strtable ntoi;
+ upb_inttable iton;
+ const upb_EnumValueDef* values;
+ int value_count;
+ int32_t defaultval;
+ bool is_sorted; // Whether all of the values are defined in ascending order.
+};
+
+upb_EnumDef* _upb_EnumDef_At(const upb_EnumDef* e, int i) {
+ return (upb_EnumDef*)&e[i];
+}
+
+// TODO: Maybe implement this on top of a ZCOS instead?
+void _upb_EnumDef_Debug(const upb_EnumDef* e) {
+ fprintf(stderr, "enum %s (%p) {\n", e->full_name, e);
+ fprintf(stderr, " value_count: %d\n", e->value_count);
+ fprintf(stderr, " default: %d\n", e->defaultval);
+ fprintf(stderr, " is_sorted: %d\n", e->is_sorted);
+ fprintf(stderr, "}\n");
+}
+
+const upb_MiniTable_Enum* _upb_EnumDef_MiniTable(const upb_EnumDef* e) {
+ return e->layout;
+}
+
+bool _upb_EnumDef_Insert(upb_EnumDef* e, upb_EnumValueDef* v, upb_Arena* a) {
+ const char* name = upb_EnumValueDef_Name(v);
+ const upb_value val = upb_value_constptr(v);
+ bool ok = upb_strtable_insert(&e->ntoi, name, strlen(name), val, a);
+ if (!ok) return false;
+
+ // Multiple enumerators can have the same number, first one wins.
+ const int number = upb_EnumValueDef_Number(v);
+ if (!upb_inttable_lookup(&e->iton, number, NULL)) {
+ return upb_inttable_insert(&e->iton, number, val, a);
+ }
+ return true;
+}
+
+const google_protobuf_EnumOptions* upb_EnumDef_Options(const upb_EnumDef* e) {
+ return e->opts;
+}
+
+bool upb_EnumDef_HasOptions(const upb_EnumDef* e) {
+ return e->opts != (void*)kUpbDefOptDefault;
+}
+
+const char* upb_EnumDef_FullName(const upb_EnumDef* e) { return e->full_name; }
+
+const char* upb_EnumDef_Name(const upb_EnumDef* e) {
+ return _upb_DefBuilder_FullToShort(e->full_name);
+}
+
+const upb_FileDef* upb_EnumDef_File(const upb_EnumDef* e) { return e->file; }
+
+const upb_MessageDef* upb_EnumDef_ContainingType(const upb_EnumDef* e) {
+ return e->containing_type;
+}
+
+int32_t upb_EnumDef_Default(const upb_EnumDef* e) {
+ UPB_ASSERT(upb_EnumDef_FindValueByNumber(e, e->defaultval));
+ return e->defaultval;
+}
+
+int upb_EnumDef_ValueCount(const upb_EnumDef* e) { return e->value_count; }
+
+const upb_EnumValueDef* upb_EnumDef_FindValueByName(const upb_EnumDef* e,
+ const char* name) {
+ return upb_EnumDef_FindValueByNameWithSize(e, name, strlen(name));
+}
+
+const upb_EnumValueDef* upb_EnumDef_FindValueByNameWithSize(
+ const upb_EnumDef* e, const char* name, size_t size) {
+ upb_value v;
+ return upb_strtable_lookup2(&e->ntoi, name, size, &v)
+ ? upb_value_getconstptr(v)
+ : NULL;
+}
+
+const upb_EnumValueDef* upb_EnumDef_FindValueByNumber(const upb_EnumDef* e,
+ int32_t num) {
+ upb_value v;
+ return upb_inttable_lookup(&e->iton, num, &v) ? upb_value_getconstptr(v)
+ : NULL;
+}
+
+bool upb_EnumDef_CheckNumber(const upb_EnumDef* e, int32_t num) {
+ // We could use upb_EnumDef_FindValueByNumber(e, num) != NULL, but we expect
+ // this to be faster (especially for small numbers).
+ return upb_MiniTable_Enum_CheckValue(e->layout, num);
+}
+
+const upb_EnumValueDef* upb_EnumDef_Value(const upb_EnumDef* e, int i) {
+ UPB_ASSERT(0 <= i && i < e->value_count);
+ return _upb_EnumValueDef_At(e->values, i);
+}
+
+bool upb_EnumDef_MiniDescriptorEncode(const upb_EnumDef* e, upb_Arena* a,
+ upb_StringView* out) {
+ upb_DescState s;
+ _upb_DescState_Init(&s);
+
+ const upb_EnumValueDef** sorted = NULL;
+ if (!e->is_sorted) {
+ sorted = _upb_EnumValueDefs_Sorted(e->values, e->value_count, a);
+ if (!sorted) return false;
+ }
+
+ upb_MtDataEncoder_StartEnum(&s.e);
+
+ // Duplicate values are allowed but we only encode each value once.
+ uint32_t previous = 0;
+
+ for (size_t i = 0; i < e->value_count; i++) {
+ const uint32_t current =
+ upb_EnumValueDef_Number(sorted ? sorted[i] : upb_EnumDef_Value(e, i));
+ if (i != 0 && previous == current) continue;
+
+ if (!_upb_DescState_Grow(&s, a)) return false;
+ s.ptr = upb_MtDataEncoder_PutEnumValue(&s.e, s.ptr, current);
+ previous = current;
+ }
+
+ if (!_upb_DescState_Grow(&s, a)) return false;
+ s.ptr = upb_MtDataEncoder_EndEnum(&s.e, s.ptr);
+
+ // There will always be room for this '\0' in the encoder buffer because
+ // kUpb_MtDataEncoder_MinSize is overkill for upb_MtDataEncoder_EndEnum().
+ UPB_ASSERT(s.ptr < s.buf + s.bufsize);
+ *s.ptr = '\0';
+
+ out->data = s.buf;
+ out->size = s.ptr - s.buf;
+ return true;
+}
+
+static upb_MiniTable_Enum* create_enumlayout(upb_DefBuilder* ctx,
+ const upb_EnumDef* e) {
+ upb_StringView sv;
+ bool ok = upb_EnumDef_MiniDescriptorEncode(e, ctx->tmp_arena, &sv);
+ if (!ok) _upb_DefBuilder_Errf(ctx, "OOM while building enum MiniDescriptor");
+
+ upb_Status status;
+ upb_MiniTable_Enum* layout =
+ upb_MiniTable_BuildEnum(sv.data, sv.size, ctx->arena, &status);
+ if (!layout)
+ _upb_DefBuilder_Errf(ctx, "Error building enum MiniTable: %s", status.msg);
+ return layout;
+}
+
+static void create_enumdef(upb_DefBuilder* ctx, const char* prefix,
+ const google_protobuf_EnumDescriptorProto* enum_proto,
+ upb_EnumDef* e) {
+ const google_protobuf_EnumValueDescriptorProto* const* values;
+ upb_StringView name;
+ size_t n;
+
+ // Must happen before _upb_DefBuilder_Add()
+ e->file = _upb_DefBuilder_File(ctx);
+
+ name = google_protobuf_EnumDescriptorProto_name(enum_proto);
+ _upb_DefBuilder_CheckIdentNotFull(ctx, name);
+
+ e->full_name = _upb_DefBuilder_MakeFullName(ctx, prefix, name);
+ _upb_DefBuilder_Add(ctx, e->full_name,
+ _upb_DefType_Pack(e, UPB_DEFTYPE_ENUM));
+
+ values = google_protobuf_EnumDescriptorProto_value(enum_proto, &n);
+
+ bool ok = upb_strtable_init(&e->ntoi, n, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+
+ ok = upb_inttable_init(&e->iton, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+
+ e->defaultval = 0;
+ e->value_count = n;
+ e->values = _upb_EnumValueDefs_New(ctx, prefix, n, values, e, &e->is_sorted);
+
+ if (n == 0) {
+ _upb_DefBuilder_Errf(ctx, "enums must contain at least one value (%s)",
+ e->full_name);
+ }
+
+ UBP_DEF_SET_OPTIONS(e->opts, EnumDescriptorProto, EnumOptions, enum_proto);
+
+ upb_inttable_compact(&e->iton, ctx->arena);
+
+ if (upb_FileDef_Syntax(e->file) == kUpb_Syntax_Proto2) {
+ if (ctx->layout) {
+ UPB_ASSERT(ctx->enum_count < ctx->layout->enum_count);
+ e->layout = ctx->layout->enums[ctx->enum_count++];
+ } else {
+ e->layout = create_enumlayout(ctx, e);
+ }
+ } else {
+ e->layout = NULL;
+ }
+}
+
+upb_EnumDef* _upb_EnumDefs_New(upb_DefBuilder* ctx, int n,
+ const google_protobuf_EnumDescriptorProto* const* protos,
+ const upb_MessageDef* containing_type) {
+ _upb_DefType_CheckPadding(sizeof(upb_EnumDef));
+
+ // If a containing type is defined then get the full name from that.
+ // Otherwise use the package name from the file def.
+ const char* name = containing_type ? upb_MessageDef_FullName(containing_type)
+ : _upb_FileDef_RawPackage(ctx->file);
+
+ upb_EnumDef* e = _upb_DefBuilder_Alloc(ctx, sizeof(upb_EnumDef) * n);
+ for (size_t i = 0; i < n; i++) {
+ create_enumdef(ctx, name, protos[i], &e[i]);
+ e[i].containing_type = containing_type;
+ }
+ return e;
+}
+
+
+
+// Must be last.
+
+struct upb_EnumValueDef {
+ const google_protobuf_EnumValueOptions* opts;
+ const upb_EnumDef* parent;
+ const char* full_name;
+ int32_t number;
+};
+
+upb_EnumValueDef* _upb_EnumValueDef_At(const upb_EnumValueDef* v, int i) {
+ return (upb_EnumValueDef*)&v[i];
+}
+
+static int _upb_EnumValueDef_Compare(const void* p1, const void* p2) {
+ const uint32_t v1 = (*(const upb_EnumValueDef**)p1)->number;
+ const uint32_t v2 = (*(const upb_EnumValueDef**)p2)->number;
+ return (v1 < v2) ? -1 : (v1 > v2);
+}
+
+const upb_EnumValueDef** _upb_EnumValueDefs_Sorted(const upb_EnumValueDef* v,
+ int n, upb_Arena* a) {
+ // TODO: Try to replace this arena alloc with a persistent scratch buffer.
+ upb_EnumValueDef** out =
+ (upb_EnumValueDef**)upb_Arena_Malloc(a, n * sizeof(void*));
+ if (!out) return NULL;
+
+ for (int i = 0; i < n; i++) {
+ out[i] = (upb_EnumValueDef*)&v[i];
+ }
+ qsort(out, n, sizeof(void*), _upb_EnumValueDef_Compare);
+
+ return (const upb_EnumValueDef**)out;
+}
+
+const google_protobuf_EnumValueOptions* upb_EnumValueDef_Options(
+ const upb_EnumValueDef* v) {
+ return v->opts;
+}
+
+bool upb_EnumValueDef_HasOptions(const upb_EnumValueDef* v) {
+ return v->opts != (void*)kUpbDefOptDefault;
+}
+
+const upb_EnumDef* upb_EnumValueDef_Enum(const upb_EnumValueDef* v) {
+ return v->parent;
+}
+
+const char* upb_EnumValueDef_FullName(const upb_EnumValueDef* v) {
+ return v->full_name;
+}
+
+const char* upb_EnumValueDef_Name(const upb_EnumValueDef* v) {
+ return _upb_DefBuilder_FullToShort(v->full_name);
+}
+
+int32_t upb_EnumValueDef_Number(const upb_EnumValueDef* v) { return v->number; }
+
+uint32_t upb_EnumValueDef_Index(const upb_EnumValueDef* v) {
+ // Compute index in our parent's array.
+ return v - upb_EnumDef_Value(v->parent, 0);
+}
+
+static void create_enumvaldef(upb_DefBuilder* ctx, const char* prefix,
+ const google_protobuf_EnumValueDescriptorProto* val_proto,
+ upb_EnumDef* e, upb_EnumValueDef* v) {
+ upb_StringView name = google_protobuf_EnumValueDescriptorProto_name(val_proto);
+
+ v->parent = e; // Must happen prior to _upb_DefBuilder_Add()
+ v->full_name = _upb_DefBuilder_MakeFullName(ctx, prefix, name);
+ v->number = google_protobuf_EnumValueDescriptorProto_number(val_proto);
+ _upb_DefBuilder_Add(ctx, v->full_name,
+ _upb_DefType_Pack(v, UPB_DEFTYPE_ENUMVAL));
+
+ UBP_DEF_SET_OPTIONS(v->opts, EnumValueDescriptorProto, EnumValueOptions,
+ val_proto);
+
+ bool ok = _upb_EnumDef_Insert(e, v, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+}
+
+// Allocate and initialize an array of |n| enum value defs owned by |e|.
+upb_EnumValueDef* _upb_EnumValueDefs_New(
+ upb_DefBuilder* ctx, const char* prefix, int n,
+ const google_protobuf_EnumValueDescriptorProto* const* protos, upb_EnumDef* e,
+ bool* is_sorted) {
+ _upb_DefType_CheckPadding(sizeof(upb_EnumValueDef));
+
+ upb_EnumValueDef* v =
+ _upb_DefBuilder_Alloc(ctx, sizeof(upb_EnumValueDef) * n);
+
+ *is_sorted = true;
+ uint32_t previous = 0;
+ for (size_t i = 0; i < n; i++) {
+ create_enumvaldef(ctx, prefix, protos[i], e, &v[i]);
+
+ const uint32_t current = v[i].number;
+ if (previous > current) *is_sorted = false;
+ previous = current;
+ }
+
+ if (upb_FileDef_Syntax(ctx->file) == kUpb_Syntax_Proto3 && n > 0 &&
+ v[0].number != 0) {
+ _upb_DefBuilder_Errf(ctx,
+ "for proto3, the first enum value must be zero (%s)",
+ upb_EnumDef_FullName(e));
+ }
+
+ return v;
+}
+
+
+
+// Must be last.
+
+struct upb_ExtensionRange {
+ const google_protobuf_ExtensionRangeOptions* opts;
+ int32_t start;
+ int32_t end;
+};
+
+upb_ExtensionRange* _upb_ExtensionRange_At(const upb_ExtensionRange* r, int i) {
+ return (upb_ExtensionRange*)&r[i];
+}
+
+const google_protobuf_ExtensionRangeOptions* upb_ExtensionRange_Options(
+ const upb_ExtensionRange* r) {
+ return r->opts;
+}
+
+bool upb_ExtensionRange_HasOptions(const upb_ExtensionRange* r) {
+ return r->opts != (void*)kUpbDefOptDefault;
+}
+
+int32_t upb_ExtensionRange_Start(const upb_ExtensionRange* r) {
+ return r->start;
+}
+
+int32_t upb_ExtensionRange_End(const upb_ExtensionRange* r) { return r->end; }
+
+upb_ExtensionRange* _upb_ExtensionRanges_New(
+ upb_DefBuilder* ctx, int n,
+ const google_protobuf_DescriptorProto_ExtensionRange* const* protos,
+ const upb_MessageDef* m) {
+ upb_ExtensionRange* r =
+ _upb_DefBuilder_Alloc(ctx, sizeof(upb_ExtensionRange) * n);
+
+ for (int i = 0; i < n; i++) {
+ const int32_t start =
+ google_protobuf_DescriptorProto_ExtensionRange_start(protos[i]);
+ const int32_t end = google_protobuf_DescriptorProto_ExtensionRange_end(protos[i]);
+ const int32_t max =
+ google_protobuf_MessageOptions_message_set_wire_format(upb_MessageDef_Options(m))
+ ? INT32_MAX
+ : kUpb_MaxFieldNumber + 1;
+
+ // A full validation would also check that each range is disjoint, and that
+ // none of the fields overlap with the extension ranges, but we are just
+ // sanity checking here.
+ if (start < 1 || end <= start || end > max) {
+ _upb_DefBuilder_Errf(ctx,
+ "Extension range (%d, %d) is invalid, message=%s\n",
+ (int)start, (int)end, upb_MessageDef_FullName(m));
+ }
+
+ r[i].start = start;
+ r[i].end = end;
+ UBP_DEF_SET_OPTIONS(r[i].opts, DescriptorProto_ExtensionRange,
+ ExtensionRangeOptions, protos[i]);
+ }
+
+ return r;
+}
+
+
+#include <ctype.h>
+#include <errno.h>
+
+
+// Must be last.
+
+#define UPB_FIELD_TYPE_UNSPECIFIED 0
+
+typedef struct {
+ size_t len;
+ char str[1]; // Null-terminated string data follows.
+} str_t;
+
+struct upb_FieldDef {
+ const google_protobuf_FieldOptions* opts;
+ const upb_FileDef* file;
+ const upb_MessageDef* msgdef;
+ const char* full_name;
+ const char* json_name;
+ union {
+ int64_t sint;
+ uint64_t uint;
+ double dbl;
+ float flt;
+ bool boolean;
+ str_t* str;
+ } defaultval;
+ union {
+ const upb_OneofDef* oneof;
+ const upb_MessageDef* extension_scope;
+ } scope;
+ union {
+ const upb_MessageDef* msgdef;
+ const upb_EnumDef* enumdef;
+ const google_protobuf_FieldDescriptorProto* unresolved;
+ } sub;
+ uint32_t number_;
+ uint16_t index_;
+ uint16_t layout_index; // Index into msgdef->layout->fields or file->exts
+ bool has_default;
+ bool is_extension_;
+ bool is_packed_;
+ bool proto3_optional_;
+ bool has_json_name_;
+ upb_FieldType type_;
+ upb_Label label_;
+#if UINTPTR_MAX == 0xffffffff
+ uint32_t padding; // Increase size to a multiple of 8.
+#endif
+};
+
+upb_FieldDef* _upb_FieldDef_At(const upb_FieldDef* f, int i) {
+ return (upb_FieldDef*)&f[i];
+}
+
+const google_protobuf_FieldOptions* upb_FieldDef_Options(const upb_FieldDef* f) {
+ return f->opts;
+}
+
+bool upb_FieldDef_HasOptions(const upb_FieldDef* f) {
+ return f->opts != (void*)kUpbDefOptDefault;
+}
+
+const char* upb_FieldDef_FullName(const upb_FieldDef* f) {
+ return f->full_name;
+}
+
+upb_CType upb_FieldDef_CType(const upb_FieldDef* f) {
+ switch (f->type_) {
+ case kUpb_FieldType_Double:
+ return kUpb_CType_Double;
+ case kUpb_FieldType_Float:
+ return kUpb_CType_Float;
+ case kUpb_FieldType_Int64:
+ case kUpb_FieldType_SInt64:
+ case kUpb_FieldType_SFixed64:
+ return kUpb_CType_Int64;
+ case kUpb_FieldType_Int32:
+ case kUpb_FieldType_SFixed32:
+ case kUpb_FieldType_SInt32:
+ return kUpb_CType_Int32;
+ case kUpb_FieldType_UInt64:
+ case kUpb_FieldType_Fixed64:
+ return kUpb_CType_UInt64;
+ case kUpb_FieldType_UInt32:
+ case kUpb_FieldType_Fixed32:
+ return kUpb_CType_UInt32;
+ case kUpb_FieldType_Enum:
+ return kUpb_CType_Enum;
+ case kUpb_FieldType_Bool:
+ return kUpb_CType_Bool;
+ case kUpb_FieldType_String:
+ return kUpb_CType_String;
+ case kUpb_FieldType_Bytes:
+ return kUpb_CType_Bytes;
+ case kUpb_FieldType_Group:
+ case kUpb_FieldType_Message:
+ return kUpb_CType_Message;
+ }
+ UPB_UNREACHABLE();
+}
+
+upb_FieldType upb_FieldDef_Type(const upb_FieldDef* f) { return f->type_; }
+
+uint32_t upb_FieldDef_Index(const upb_FieldDef* f) { return f->index_; }
+
+upb_Label upb_FieldDef_Label(const upb_FieldDef* f) { return f->label_; }
+
+uint32_t upb_FieldDef_Number(const upb_FieldDef* f) { return f->number_; }
+
+bool upb_FieldDef_IsExtension(const upb_FieldDef* f) {
+ return f->is_extension_;
+}
+
+bool upb_FieldDef_IsPacked(const upb_FieldDef* f) { return f->is_packed_; }
+
+const char* upb_FieldDef_Name(const upb_FieldDef* f) {
+ return _upb_DefBuilder_FullToShort(f->full_name);
+}
+
+const char* upb_FieldDef_JsonName(const upb_FieldDef* f) {
+ return f->json_name;
+}
+
+bool upb_FieldDef_HasJsonName(const upb_FieldDef* f) {
+ return f->has_json_name_;
+}
+
+const upb_FileDef* upb_FieldDef_File(const upb_FieldDef* f) { return f->file; }
+
+const upb_MessageDef* upb_FieldDef_ContainingType(const upb_FieldDef* f) {
+ return f->msgdef;
+}
+
+const upb_MessageDef* upb_FieldDef_ExtensionScope(const upb_FieldDef* f) {
+ return f->is_extension_ ? f->scope.extension_scope : NULL;
+}
+
+const upb_OneofDef* upb_FieldDef_ContainingOneof(const upb_FieldDef* f) {
+ return f->is_extension_ ? NULL : f->scope.oneof;
+}
+
+const upb_OneofDef* upb_FieldDef_RealContainingOneof(const upb_FieldDef* f) {
+ const upb_OneofDef* oneof = upb_FieldDef_ContainingOneof(f);
+ if (!oneof || upb_OneofDef_IsSynthetic(oneof)) return NULL;
+ return oneof;
+}
+
+upb_MessageValue upb_FieldDef_Default(const upb_FieldDef* f) {
+ UPB_ASSERT(!upb_FieldDef_IsSubMessage(f));
+ upb_MessageValue ret;
+
+ switch (upb_FieldDef_CType(f)) {
+ case kUpb_CType_Bool:
+ return (upb_MessageValue){.bool_val = f->defaultval.boolean};
+ case kUpb_CType_Int64:
+ return (upb_MessageValue){.int64_val = f->defaultval.sint};
+ case kUpb_CType_UInt64:
+ return (upb_MessageValue){.uint64_val = f->defaultval.uint};
+ case kUpb_CType_Enum:
+ case kUpb_CType_Int32:
+ return (upb_MessageValue){.int32_val = (int32_t)f->defaultval.sint};
+ case kUpb_CType_UInt32:
+ return (upb_MessageValue){.uint32_val = (uint32_t)f->defaultval.uint};
+ case kUpb_CType_Float:
+ return (upb_MessageValue){.float_val = f->defaultval.flt};
+ case kUpb_CType_Double:
+ return (upb_MessageValue){.double_val = f->defaultval.dbl};
+ case kUpb_CType_String:
+ case kUpb_CType_Bytes: {
+ str_t* str = f->defaultval.str;
+ if (str) {
+ return (upb_MessageValue){
+ .str_val = (upb_StringView){.data = str->str, .size = str->len}};
+ } else {
+ return (upb_MessageValue){
+ .str_val = (upb_StringView){.data = NULL, .size = 0}};
+ }
+ }
+ default:
+ UPB_UNREACHABLE();
+ }
+
+ return ret;
+}
+
+const upb_MessageDef* upb_FieldDef_MessageSubDef(const upb_FieldDef* f) {
+ return upb_FieldDef_CType(f) == kUpb_CType_Message ? f->sub.msgdef : NULL;
+}
+
+const upb_EnumDef* upb_FieldDef_EnumSubDef(const upb_FieldDef* f) {
+ return upb_FieldDef_CType(f) == kUpb_CType_Enum ? f->sub.enumdef : NULL;
+}
+
+const upb_MiniTable_Field* upb_FieldDef_MiniTable(const upb_FieldDef* f) {
+ UPB_ASSERT(!upb_FieldDef_IsExtension(f));
+ const upb_MiniTable* layout = upb_MessageDef_MiniTable(f->msgdef);
+ return &layout->fields[f->layout_index];
+}
+
+const upb_MiniTable_Extension* _upb_FieldDef_ExtensionMiniTable(
+ const upb_FieldDef* f) {
+ UPB_ASSERT(upb_FieldDef_IsExtension(f));
+ const upb_FileDef* file = upb_FieldDef_File(f);
+ return _upb_FileDef_ExtensionMiniTable(file, f->layout_index);
+}
+
+bool _upb_FieldDef_IsClosedEnum(const upb_FieldDef* f) {
+ if (UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3) return false;
+ if (f->type_ != kUpb_FieldType_Enum) return false;
+
+ // TODO(https://github.com/protocolbuffers/upb/issues/541):
+ // fix map enum values to check for unknown enum values and put
+ // them in the unknown field set.
+ if (upb_MessageDef_IsMapEntry(upb_FieldDef_ContainingType(f))) {
+ return false;
+ }
+
+ // TODO: Maybe make is_proto2 a bool at creation?
+ const upb_FileDef* file = upb_EnumDef_File(f->sub.enumdef);
+ return upb_FileDef_Syntax(file) == kUpb_Syntax_Proto2;
+}
+
+bool _upb_FieldDef_IsProto3Optional(const upb_FieldDef* f) {
+ return f->proto3_optional_;
+}
+
+int _upb_FieldDef_LayoutIndex(const upb_FieldDef* f) { return f->layout_index; }
+
+uint64_t _upb_FieldDef_Modifiers(const upb_FieldDef* f) {
+ uint64_t out = f->is_packed_ ? kUpb_FieldModifier_IsPacked : 0;
+
+ switch (f->label_) {
+ case kUpb_Label_Optional:
+ if (!upb_FieldDef_HasPresence(f)) {
+ out |= kUpb_FieldModifier_IsProto3Singular;
+ }
+ break;
+ case kUpb_Label_Repeated:
+ out |= kUpb_FieldModifier_IsRepeated;
+ break;
+ case kUpb_Label_Required:
+ out |= kUpb_FieldModifier_IsRequired;
+ break;
+ }
+
+ if (_upb_FieldDef_IsClosedEnum(f)) {
+ out |= kUpb_FieldModifier_IsClosedEnum;
+ }
+ return out;
+}
+
+bool upb_FieldDef_HasDefault(const upb_FieldDef* f) { return f->has_default; }
+
+bool upb_FieldDef_HasPresence(const upb_FieldDef* f) {
+ if (upb_FieldDef_IsRepeated(f)) return false;
+ const upb_FileDef* file = upb_FieldDef_File(f);
+ return upb_FieldDef_IsSubMessage(f) || upb_FieldDef_ContainingOneof(f) ||
+ upb_FileDef_Syntax(file) == kUpb_Syntax_Proto2;
+}
+
+bool upb_FieldDef_HasSubDef(const upb_FieldDef* f) {
+ return upb_FieldDef_IsSubMessage(f) ||
+ upb_FieldDef_CType(f) == kUpb_CType_Enum;
+}
+
+bool upb_FieldDef_IsMap(const upb_FieldDef* f) {
+ return upb_FieldDef_IsRepeated(f) && upb_FieldDef_IsSubMessage(f) &&
+ upb_MessageDef_IsMapEntry(upb_FieldDef_MessageSubDef(f));
+}
+
+bool upb_FieldDef_IsOptional(const upb_FieldDef* f) {
+ return upb_FieldDef_Label(f) == kUpb_Label_Optional;
+}
+
+bool upb_FieldDef_IsPrimitive(const upb_FieldDef* f) {
+ return !upb_FieldDef_IsString(f) && !upb_FieldDef_IsSubMessage(f);
+}
+
+bool upb_FieldDef_IsRepeated(const upb_FieldDef* f) {
+ return upb_FieldDef_Label(f) == kUpb_Label_Repeated;
+}
+
+bool upb_FieldDef_IsRequired(const upb_FieldDef* f) {
+ return upb_FieldDef_Label(f) == kUpb_Label_Required;
+}
+
+bool upb_FieldDef_IsString(const upb_FieldDef* f) {
+ return upb_FieldDef_CType(f) == kUpb_CType_String ||
+ upb_FieldDef_CType(f) == kUpb_CType_Bytes;
+}
+
+bool upb_FieldDef_IsSubMessage(const upb_FieldDef* f) {
+ return upb_FieldDef_CType(f) == kUpb_CType_Message;
+}
+
+static bool between(int32_t x, int32_t low, int32_t high) {
+ return x >= low && x <= high;
+}
+
+bool upb_FieldDef_checklabel(int32_t label) { return between(label, 1, 3); }
+bool upb_FieldDef_checktype(int32_t type) { return between(type, 1, 11); }
+bool upb_FieldDef_checkintfmt(int32_t fmt) { return between(fmt, 1, 3); }
+
+bool upb_FieldDef_checkdescriptortype(int32_t type) {
+ return between(type, 1, 18);
+}
+
+static bool streql2(const char* a, size_t n, const char* b) {
+ return n == strlen(b) && memcmp(a, b, n) == 0;
+}
+
+// Implement the transformation as described in the spec:
+// 1. upper case all letters after an underscore.
+// 2. remove all underscores.
+static char* make_json_name(const char* name, size_t size, upb_Arena* a) {
+ char* out = upb_Arena_Malloc(a, size + 1); // +1 is to add a trailing '\0'
+ if (out == NULL) return NULL;
+
+ bool ucase_next = false;
+ char* des = out;
+ for (size_t i = 0; i < size; i++) {
+ if (name[i] == '_') {
+ ucase_next = true;
+ } else {
+ *des++ = ucase_next ? toupper(name[i]) : name[i];
+ ucase_next = false;
+ }
+ }
+ *des++ = '\0';
+ return out;
+}
+
+static str_t* newstr(upb_DefBuilder* ctx, const char* data, size_t len) {
+ str_t* ret = _upb_DefBuilder_Alloc(ctx, sizeof(*ret) + len);
+ if (!ret) _upb_DefBuilder_OomErr(ctx);
+ ret->len = len;
+ if (len) memcpy(ret->str, data, len);
+ ret->str[len] = '\0';
+ return ret;
+}
+
+static str_t* unescape(upb_DefBuilder* ctx, const upb_FieldDef* f,
+ const char* data, size_t len) {
+ // Size here is an upper bound; escape sequences could ultimately shrink it.
+ str_t* ret = _upb_DefBuilder_Alloc(ctx, sizeof(*ret) + len);
+ char* dst = &ret->str[0];
+ const char* src = data;
+ const char* end = data + len;
+
+ while (src < end) {
+ if (*src == '\\') {
+ src++;
+ *dst++ = _upb_DefBuilder_ParseEscape(ctx, f, &src, end);
+ } else {
+ *dst++ = *src++;
+ }
+ }
+
+ ret->len = dst - &ret->str[0];
+ return ret;
+}
+
+static void parse_default(upb_DefBuilder* ctx, const char* str, size_t len,
+ upb_FieldDef* f) {
+ char* end;
+ char nullz[64];
+ errno = 0;
+
+ switch (upb_FieldDef_CType(f)) {
+ case kUpb_CType_Int32:
+ case kUpb_CType_Int64:
+ case kUpb_CType_UInt32:
+ case kUpb_CType_UInt64:
+ case kUpb_CType_Double:
+ case kUpb_CType_Float:
+ /* Standard C number parsing functions expect null-terminated strings. */
+ if (len >= sizeof(nullz) - 1) {
+ _upb_DefBuilder_Errf(ctx, "Default too long: %.*s", (int)len, str);
+ }
+ memcpy(nullz, str, len);
+ nullz[len] = '\0';
+ str = nullz;
+ break;
+ default:
+ break;
+ }
+
+ switch (upb_FieldDef_CType(f)) {
+ case kUpb_CType_Int32: {
+ long val = strtol(str, &end, 0);
+ if (val > INT32_MAX || val < INT32_MIN || errno == ERANGE || *end) {
+ goto invalid;
+ }
+ f->defaultval.sint = val;
+ break;
+ }
+ case kUpb_CType_Enum: {
+ const upb_EnumDef* e = f->sub.enumdef;
+ const upb_EnumValueDef* ev =
+ upb_EnumDef_FindValueByNameWithSize(e, str, len);
+ if (!ev) {
+ goto invalid;
+ }
+ f->defaultval.sint = upb_EnumValueDef_Number(ev);
+ break;
+ }
+ case kUpb_CType_Int64: {
+ long long val = strtoll(str, &end, 0);
+ if (val > INT64_MAX || val < INT64_MIN || errno == ERANGE || *end) {
+ goto invalid;
+ }
+ f->defaultval.sint = val;
+ break;
+ }
+ case kUpb_CType_UInt32: {
+ unsigned long val = strtoul(str, &end, 0);
+ if (val > UINT32_MAX || errno == ERANGE || *end) {
+ goto invalid;
+ }
+ f->defaultval.uint = val;
+ break;
+ }
+ case kUpb_CType_UInt64: {
+ unsigned long long val = strtoull(str, &end, 0);
+ if (val > UINT64_MAX || errno == ERANGE || *end) {
+ goto invalid;
+ }
+ f->defaultval.uint = val;
+ break;
+ }
+ case kUpb_CType_Double: {
+ double val = strtod(str, &end);
+ if (errno == ERANGE || *end) {
+ goto invalid;
+ }
+ f->defaultval.dbl = val;
+ break;
+ }
+ case kUpb_CType_Float: {
+ float val = strtof(str, &end);
+ if (errno == ERANGE || *end) {
+ goto invalid;
+ }
+ f->defaultval.flt = val;
+ break;
+ }
+ case kUpb_CType_Bool: {
+ if (streql2(str, len, "false")) {
+ f->defaultval.boolean = false;
+ } else if (streql2(str, len, "true")) {
+ f->defaultval.boolean = true;
+ } else {
+ goto invalid;
+ }
+ break;
+ }
+ case kUpb_CType_String:
+ f->defaultval.str = newstr(ctx, str, len);
+ break;
+ case kUpb_CType_Bytes:
+ f->defaultval.str = unescape(ctx, f, str, len);
+ break;
+ case kUpb_CType_Message:
+ /* Should not have a default value. */
+ _upb_DefBuilder_Errf(ctx, "Message should not have a default (%s)",
+ upb_FieldDef_FullName(f));
+ }
+
+ return;
+
+invalid:
+ _upb_DefBuilder_Errf(ctx, "Invalid default '%.*s' for field %s of type %d",
+ (int)len, str, upb_FieldDef_FullName(f),
+ (int)upb_FieldDef_Type(f));
+}
+
+static void set_default_default(upb_DefBuilder* ctx, upb_FieldDef* f) {
+ switch (upb_FieldDef_CType(f)) {
+ case kUpb_CType_Int32:
+ case kUpb_CType_Int64:
+ f->defaultval.sint = 0;
+ break;
+ case kUpb_CType_UInt64:
+ case kUpb_CType_UInt32:
+ f->defaultval.uint = 0;
+ break;
+ case kUpb_CType_Double:
+ case kUpb_CType_Float:
+ f->defaultval.dbl = 0;
+ break;
+ case kUpb_CType_String:
+ case kUpb_CType_Bytes:
+ f->defaultval.str = newstr(ctx, NULL, 0);
+ break;
+ case kUpb_CType_Bool:
+ f->defaultval.boolean = false;
+ break;
+ case kUpb_CType_Enum: {
+ const upb_EnumValueDef* v = upb_EnumDef_Value(f->sub.enumdef, 0);
+ f->defaultval.sint = upb_EnumValueDef_Number(v);
+ }
+ case kUpb_CType_Message:
+ break;
+ }
+}
+
+static void _upb_FieldDef_Create(upb_DefBuilder* ctx, const char* prefix,
+ const google_protobuf_FieldDescriptorProto* field_proto,
+ upb_MessageDef* m, upb_FieldDef* f) {
+ // Must happen before _upb_DefBuilder_Add()
+ f->file = _upb_DefBuilder_File(ctx);
+
+ if (!google_protobuf_FieldDescriptorProto_has_name(field_proto)) {
+ _upb_DefBuilder_Errf(ctx, "field has no name");
+ }
+
+ const upb_StringView name = google_protobuf_FieldDescriptorProto_name(field_proto);
+ _upb_DefBuilder_CheckIdentNotFull(ctx, name);
+
+ f->has_json_name_ = google_protobuf_FieldDescriptorProto_has_json_name(field_proto);
+ if (f->has_json_name_) {
+ const upb_StringView sv =
+ google_protobuf_FieldDescriptorProto_json_name(field_proto);
+ f->json_name = upb_strdup2(sv.data, sv.size, ctx->arena);
+ } else {
+ f->json_name = make_json_name(name.data, name.size, ctx->arena);
+ }
+ if (!f->json_name) _upb_DefBuilder_OomErr(ctx);
+
+ f->full_name = _upb_DefBuilder_MakeFullName(ctx, prefix, name);
+ f->label_ = (int)google_protobuf_FieldDescriptorProto_label(field_proto);
+ f->number_ = google_protobuf_FieldDescriptorProto_number(field_proto);
+ f->proto3_optional_ =
+ google_protobuf_FieldDescriptorProto_proto3_optional(field_proto);
+ f->msgdef = m;
+ f->scope.oneof = NULL;
+
+ const bool has_type = google_protobuf_FieldDescriptorProto_has_type(field_proto);
+ const bool has_type_name =
+ google_protobuf_FieldDescriptorProto_has_type_name(field_proto);
+
+ f->type_ = (int)google_protobuf_FieldDescriptorProto_type(field_proto);
+
+ if (has_type) {
+ switch (f->type_) {
+ case kUpb_FieldType_Message:
+ case kUpb_FieldType_Group:
+ case kUpb_FieldType_Enum:
+ if (!has_type_name) {
+ _upb_DefBuilder_Errf(ctx, "field of type %d requires type name (%s)",
+ (int)f->type_, f->full_name);
+ }
+ break;
+ default:
+ if (has_type_name) {
+ _upb_DefBuilder_Errf(
+ ctx, "invalid type for field with type_name set (%s, %d)",
+ f->full_name, (int)f->type_);
+ }
+ }
+ } else if (has_type_name) {
+ f->type_ =
+ UPB_FIELD_TYPE_UNSPECIFIED; // We'll fill this in in resolve_fielddef()
+ }
+
+ if (f->type_ < kUpb_FieldType_Double || f->type_ > kUpb_FieldType_SInt64) {
+ _upb_DefBuilder_Errf(ctx, "invalid type for field %s (%d)", f->full_name,
+ f->type_);
+ }
+
+ if (f->label_ < kUpb_Label_Optional || f->label_ > kUpb_Label_Repeated) {
+ _upb_DefBuilder_Errf(ctx, "invalid label for field %s (%d)", f->full_name,
+ f->label_);
+ }
+
+ /* We can't resolve the subdef or (in the case of extensions) the containing
+ * message yet, because it may not have been defined yet. We stash a pointer
+ * to the field_proto until later when we can properly resolve it. */
+ f->sub.unresolved = field_proto;
+
+ if (f->label_ == kUpb_Label_Required &&
+ upb_FileDef_Syntax(f->file) == kUpb_Syntax_Proto3) {
+ _upb_DefBuilder_Errf(ctx, "proto3 fields cannot be required (%s)",
+ f->full_name);
+ }
+
+ if (google_protobuf_FieldDescriptorProto_has_oneof_index(field_proto)) {
+ uint32_t oneof_index = google_protobuf_FieldDescriptorProto_oneof_index(field_proto);
+
+ if (upb_FieldDef_Label(f) != kUpb_Label_Optional) {
+ _upb_DefBuilder_Errf(ctx, "fields in oneof must have OPTIONAL label (%s)",
+ f->full_name);
+ }
+
+ if (!m) {
+ _upb_DefBuilder_Errf(ctx, "oneof field (%s) has no containing msg",
+ f->full_name);
+ }
+
+ if (oneof_index >= upb_MessageDef_OneofCount(m)) {
+ _upb_DefBuilder_Errf(ctx, "oneof_index out of range (%s)", f->full_name);
+ }
+
+ upb_OneofDef* oneof = (upb_OneofDef*)upb_MessageDef_Oneof(m, oneof_index);
+ f->scope.oneof = oneof;
+
+ bool ok = _upb_OneofDef_Insert(oneof, f, name.data, name.size, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+ } else if (f->proto3_optional_) {
+ _upb_DefBuilder_Errf(ctx,
+ "field with proto3_optional was not in a oneof (%s)",
+ f->full_name);
+ }
+
+ UBP_DEF_SET_OPTIONS(f->opts, FieldDescriptorProto, FieldOptions, field_proto);
+
+ if (google_protobuf_FieldOptions_has_packed(f->opts)) {
+ f->is_packed_ = google_protobuf_FieldOptions_packed(f->opts);
+ } else {
+ // Repeated fields default to packed for proto3 only.
+ f->is_packed_ = upb_FieldDef_IsPrimitive(f) &&
+ f->label_ == kUpb_Label_Repeated &&
+ upb_FileDef_Syntax(f->file) == kUpb_Syntax_Proto3;
+ }
+}
+
+static void _upb_FieldDef_CreateExt(
+ upb_DefBuilder* ctx, const char* prefix,
+ const google_protobuf_FieldDescriptorProto* field_proto, upb_MessageDef* m,
+ upb_FieldDef* f) {
+ _upb_FieldDef_Create(ctx, prefix, field_proto, m, f);
+ f->is_extension_ = true;
+
+ if (google_protobuf_FieldDescriptorProto_has_oneof_index(field_proto)) {
+ _upb_DefBuilder_Errf(ctx, "oneof_index provided for extension field (%s)",
+ f->full_name);
+ }
+
+ f->scope.extension_scope = m;
+ _upb_DefBuilder_Add(ctx, f->full_name, _upb_DefType_Pack(f, UPB_DEFTYPE_EXT));
+ f->layout_index = ctx->ext_count++;
+
+ if (ctx->layout) {
+ UPB_ASSERT(_upb_FieldDef_ExtensionMiniTable(f)->field.number == f->number_);
+ }
+}
+
+static void _upb_FieldDef_CreateNotExt(
+ upb_DefBuilder* ctx, const char* prefix,
+ const google_protobuf_FieldDescriptorProto* field_proto, upb_MessageDef* m,
+ upb_FieldDef* f) {
+ _upb_FieldDef_Create(ctx, prefix, field_proto, m, f);
+ f->is_extension_ = false;
+
+ _upb_MessageDef_InsertField(ctx, m, f);
+
+ if (!ctx->layout) return;
+
+ const upb_MiniTable* mt = upb_MessageDef_MiniTable(m);
+ const upb_MiniTable_Field* fields = mt->fields;
+ for (int i = 0; i < mt->field_count; i++) {
+ if (fields[i].number == f->number_) {
+ f->layout_index = i;
+ return;
+ }
+ }
+
+ UPB_ASSERT(false); // It should be impossible to reach this point.
+}
+
+upb_FieldDef* _upb_FieldDefs_New(
+ upb_DefBuilder* ctx, int n,
+ const google_protobuf_FieldDescriptorProto* const* protos, const char* prefix,
+ upb_MessageDef* m, bool* is_sorted) {
+ _upb_DefType_CheckPadding(sizeof(upb_FieldDef));
+ upb_FieldDef* defs =
+ (upb_FieldDef*)_upb_DefBuilder_Alloc(ctx, sizeof(upb_FieldDef) * n);
+
+ // If we are creating extensions then is_sorted will be NULL.
+ // If we are not creating extensions then is_sorted will be non-NULL.
+ if (is_sorted) {
+ uint32_t previous = 0;
+ for (int i = 0; i < n; i++) {
+ upb_FieldDef* f = &defs[i];
+
+ _upb_FieldDef_CreateNotExt(ctx, prefix, protos[i], m, f);
+ f->index_ = i;
+ if (!ctx->layout) f->layout_index = i;
+
+ const uint32_t current = f->number_;
+ if (previous > current) *is_sorted = false;
+ previous = current;
+ }
+ } else {
+ for (int i = 0; i < n; i++) {
+ upb_FieldDef* f = &defs[i];
+
+ _upb_FieldDef_CreateExt(ctx, prefix, protos[i], m, f);
+ f->index_ = i;
+ }
+ }
+
+ return defs;
+}
+
+static void resolve_subdef(upb_DefBuilder* ctx, const char* prefix,
+ upb_FieldDef* f) {
+ const google_protobuf_FieldDescriptorProto* field_proto = f->sub.unresolved;
+ upb_StringView name =
+ google_protobuf_FieldDescriptorProto_type_name(field_proto);
+ bool has_name =
+ google_protobuf_FieldDescriptorProto_has_type_name(field_proto);
+ switch ((int)f->type_) {
+ case UPB_FIELD_TYPE_UNSPECIFIED: {
+ // Type was not specified and must be inferred.
+ UPB_ASSERT(has_name);
+ upb_deftype_t type;
+ const void* def =
+ _upb_DefBuilder_ResolveAny(ctx, f->full_name, prefix, name, &type);
+ switch (type) {
+ case UPB_DEFTYPE_ENUM:
+ f->sub.enumdef = def;
+ f->type_ = kUpb_FieldType_Enum;
+ break;
+ case UPB_DEFTYPE_MSG:
+ f->sub.msgdef = def;
+ f->type_ = kUpb_FieldType_Message; // It appears there is no way of
+ // this being a group.
+ break;
+ default:
+ _upb_DefBuilder_Errf(ctx, "Couldn't resolve type name for field %s",
+ f->full_name);
+ }
+ }
+ case kUpb_FieldType_Message:
+ case kUpb_FieldType_Group:
+ UPB_ASSERT(has_name);
+ f->sub.msgdef = _upb_DefBuilder_Resolve(ctx, f->full_name, prefix, name,
+ UPB_DEFTYPE_MSG);
+ break;
+ case kUpb_FieldType_Enum:
+ UPB_ASSERT(has_name);
+ f->sub.enumdef = _upb_DefBuilder_Resolve(ctx, f->full_name, prefix, name,
+ UPB_DEFTYPE_ENUM);
+ break;
+ default:
+ // No resolution necessary.
+ break;
+ }
+}
+
+static int _upb_FieldDef_Compare(const void* p1, const void* p2) {
+ const uint32_t v1 = (*(upb_FieldDef**)p1)->number_;
+ const uint32_t v2 = (*(upb_FieldDef**)p2)->number_;
+ return (v1 < v2) ? -1 : (v1 > v2);
+}
+
+const upb_FieldDef** _upb_FieldDefs_Sorted(const upb_FieldDef* f, int n,
+ upb_Arena* a) {
+ // TODO: Try to replace this arena alloc with a persistent scratch buffer.
+ upb_FieldDef** out = (upb_FieldDef**)upb_Arena_Malloc(a, n * sizeof(void*));
+ if (!out) return NULL;
+
+ for (int i = 0; i < n; i++) {
+ out[i] = (upb_FieldDef*)&f[i];
+ }
+ qsort(out, n, sizeof(void*), _upb_FieldDef_Compare);
+
+ for (int i = 0; i < n; i++) {
+ out[i]->layout_index = i;
+ }
+ return (const upb_FieldDef**)out;
+}
+
+bool upb_FieldDef_MiniDescriptorEncode(const upb_FieldDef* f, upb_Arena* a,
+ upb_StringView* out) {
+ UPB_ASSERT(f->is_extension_);
+
+ upb_DescState s;
+ _upb_DescState_Init(&s);
+
+ if (!_upb_DescState_Grow(&s, a)) return false;
+ s.ptr = upb_MtDataEncoder_StartMessage(&s.e, s.ptr, 0);
+
+ const int number = upb_FieldDef_Number(f);
+ const uint64_t modifiers = _upb_FieldDef_Modifiers(f);
+
+ if (!_upb_DescState_Grow(&s, a)) return false;
+ s.ptr = upb_MtDataEncoder_PutField(&s.e, s.ptr, f->type_, number, modifiers);
+
+ if (!_upb_DescState_Grow(&s, a)) return false;
+ *s.ptr = '\0';
+
+ out->data = s.buf;
+ out->size = s.ptr - s.buf;
+ return true;
+}
+
+static void resolve_extension(upb_DefBuilder* ctx, const char* prefix,
+ upb_FieldDef* f,
+ const google_protobuf_FieldDescriptorProto* field_proto) {
+ if (!google_protobuf_FieldDescriptorProto_has_extendee(field_proto)) {
+ _upb_DefBuilder_Errf(ctx, "extension for field '%s' had no extendee",
+ f->full_name);
+ }
+
+ upb_StringView name = google_protobuf_FieldDescriptorProto_extendee(field_proto);
+ const upb_MessageDef* m =
+ _upb_DefBuilder_Resolve(ctx, f->full_name, prefix, name, UPB_DEFTYPE_MSG);
+ f->msgdef = m;
+
+ if (!_upb_MessageDef_IsValidExtensionNumber(m, f->number_)) {
+ _upb_DefBuilder_Errf(
+ ctx,
+ "field number %u in extension %s has no extension range in message %s",
+ (unsigned)f->number_, f->full_name, upb_MessageDef_FullName(m));
+ }
+
+ const upb_MiniTable_Extension* ext = _upb_FieldDef_ExtensionMiniTable(f);
+
+ if (ctx->layout) {
+ UPB_ASSERT(upb_FieldDef_Number(f) == ext->field.number);
+ } else {
+ upb_StringView desc;
+ if (!upb_FieldDef_MiniDescriptorEncode(f, ctx->tmp_arena, &desc)) {
+ _upb_DefBuilder_OomErr(ctx);
+ }
+
+ upb_MiniTable_Extension* mut_ext = (upb_MiniTable_Extension*)ext;
+ upb_MiniTable_Sub sub;
+ sub.submsg = NULL;
+ sub.subenum = NULL;
+ bool ok2 = upb_MiniTable_BuildExtension(desc.data, desc.size, mut_ext,
+ upb_MessageDef_MiniTable(m), sub,
+ ctx->status);
+ if (!ok2) _upb_DefBuilder_Errf(ctx, "Could not build extension mini table");
+
+ assert(mut_ext->field.number == f->number_);
+ mut_ext->extendee = upb_MessageDef_MiniTable(m);
+ if (upb_FieldDef_IsSubMessage(f)) {
+ mut_ext->sub.submsg = upb_MessageDef_MiniTable(f->sub.msgdef);
+ } else if (mut_ext->field.descriptortype == kUpb_FieldType_Enum) {
+ mut_ext->sub.subenum = _upb_EnumDef_MiniTable(f->sub.enumdef);
+ }
+ }
+
+ bool ok = _upb_DefPool_InsertExt(ctx->symtab, ext, f);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+}
+
+static void resolve_default(upb_DefBuilder* ctx, upb_FieldDef* f,
+ const google_protobuf_FieldDescriptorProto* field_proto) {
+ // Have to delay resolving of the default value until now because of the enum
+ // case, since enum defaults are specified with a label.
+ if (google_protobuf_FieldDescriptorProto_has_default_value(field_proto)) {
+ upb_StringView defaultval =
+ google_protobuf_FieldDescriptorProto_default_value(field_proto);
+
+ if (upb_FileDef_Syntax(f->file) == kUpb_Syntax_Proto3) {
+ _upb_DefBuilder_Errf(ctx,
+ "proto3 fields cannot have explicit defaults (%s)",
+ f->full_name);
+ }
+
+ if (upb_FieldDef_IsSubMessage(f)) {
+ _upb_DefBuilder_Errf(ctx,
+ "message fields cannot have explicit defaults (%s)",
+ f->full_name);
+ }
+
+ parse_default(ctx, defaultval.data, defaultval.size, f);
+ f->has_default = true;
+ } else {
+ set_default_default(ctx, f);
+ f->has_default = false;
+ }
+}
+
+void _upb_FieldDef_Resolve(upb_DefBuilder* ctx, const char* prefix,
+ upb_FieldDef* f) {
+ // We have to stash this away since resolve_subdef() may overwrite it.
+ const google_protobuf_FieldDescriptorProto* field_proto = f->sub.unresolved;
+
+ resolve_subdef(ctx, prefix, f);
+ resolve_default(ctx, f, field_proto);
+
+ if (f->is_extension_) {
+ resolve_extension(ctx, prefix, f, field_proto);
+ }
+}
+
+
+
+// Must be last.
+
+struct upb_FileDef {
+ const google_protobuf_FileOptions* opts;
+ const char* name;
+ const char* package;
+
+ const upb_FileDef** deps;
+ const int32_t* public_deps;
+ const int32_t* weak_deps;
+ const upb_MessageDef* top_lvl_msgs;
+ const upb_EnumDef* top_lvl_enums;
+ const upb_FieldDef* top_lvl_exts;
+ const upb_ServiceDef* services;
+ const upb_MiniTable_Extension** ext_layouts;
+ const upb_DefPool* symtab;
+
+ int dep_count;
+ int public_dep_count;
+ int weak_dep_count;
+ int top_lvl_msg_count;
+ int top_lvl_enum_count;
+ int top_lvl_ext_count;
+ int service_count;
+ int ext_count; // All exts in the file.
+ upb_Syntax syntax;
+};
+
+const google_protobuf_FileOptions* upb_FileDef_Options(const upb_FileDef* f) {
+ return f->opts;
+}
+
+bool upb_FileDef_HasOptions(const upb_FileDef* f) {
+ return f->opts != (void*)kUpbDefOptDefault;
+}
+
+const char* upb_FileDef_Name(const upb_FileDef* f) { return f->name; }
+
+const char* upb_FileDef_Package(const upb_FileDef* f) {
+ return f->package ? f->package : "";
+}
+
+const char* _upb_FileDef_RawPackage(const upb_FileDef* f) { return f->package; }
+
+upb_Syntax upb_FileDef_Syntax(const upb_FileDef* f) { return f->syntax; }
+
+int upb_FileDef_TopLevelMessageCount(const upb_FileDef* f) {
+ return f->top_lvl_msg_count;
+}
+
+int upb_FileDef_DependencyCount(const upb_FileDef* f) { return f->dep_count; }
+
+int upb_FileDef_PublicDependencyCount(const upb_FileDef* f) {
+ return f->public_dep_count;
+}
+
+int upb_FileDef_WeakDependencyCount(const upb_FileDef* f) {
+ return f->weak_dep_count;
+}
+
+const int32_t* _upb_FileDef_PublicDependencyIndexes(const upb_FileDef* f) {
+ return f->public_deps;
+}
+
+const int32_t* _upb_FileDef_WeakDependencyIndexes(const upb_FileDef* f) {
+ return f->weak_deps;
+}
+
+int upb_FileDef_TopLevelEnumCount(const upb_FileDef* f) {
+ return f->top_lvl_enum_count;
+}
+
+int upb_FileDef_TopLevelExtensionCount(const upb_FileDef* f) {
+ return f->top_lvl_ext_count;
+}
+
+int upb_FileDef_ServiceCount(const upb_FileDef* f) { return f->service_count; }
+
+const upb_FileDef* upb_FileDef_Dependency(const upb_FileDef* f, int i) {
+ UPB_ASSERT(0 <= i && i < f->dep_count);
+ return f->deps[i];
+}
+
+const upb_FileDef* upb_FileDef_PublicDependency(const upb_FileDef* f, int i) {
+ UPB_ASSERT(0 <= i && i < f->public_dep_count);
+ return f->deps[f->public_deps[i]];
+}
+
+const upb_FileDef* upb_FileDef_WeakDependency(const upb_FileDef* f, int i) {
+ UPB_ASSERT(0 <= i && i < f->public_dep_count);
+ return f->deps[f->weak_deps[i]];
+}
+
+const upb_MessageDef* upb_FileDef_TopLevelMessage(const upb_FileDef* f, int i) {
+ UPB_ASSERT(0 <= i && i < f->top_lvl_msg_count);
+ return _upb_MessageDef_At(f->top_lvl_msgs, i);
+}
+
+const upb_EnumDef* upb_FileDef_TopLevelEnum(const upb_FileDef* f, int i) {
+ UPB_ASSERT(0 <= i && i < f->top_lvl_enum_count);
+ return _upb_EnumDef_At(f->top_lvl_enums, i);
+}
+
+const upb_FieldDef* upb_FileDef_TopLevelExtension(const upb_FileDef* f, int i) {
+ UPB_ASSERT(0 <= i && i < f->top_lvl_ext_count);
+ return _upb_FieldDef_At(f->top_lvl_exts, i);
+}
+
+const upb_ServiceDef* upb_FileDef_Service(const upb_FileDef* f, int i) {
+ UPB_ASSERT(0 <= i && i < f->service_count);
+ return _upb_ServiceDef_At(f->services, i);
+}
+
+const upb_DefPool* upb_FileDef_Pool(const upb_FileDef* f) { return f->symtab; }
+
+const upb_MiniTable_Extension* _upb_FileDef_ExtensionMiniTable(
+ const upb_FileDef* f, int i) {
+ return f->ext_layouts[i];
+}
+
+static char* strviewdup(upb_DefBuilder* ctx, upb_StringView view) {
+ char* ret = upb_strdup2(view.data, view.size, _upb_DefBuilder_Arena(ctx));
+ if (!ret) _upb_DefBuilder_OomErr(ctx);
+ return ret;
+}
+
+static bool streql_view(upb_StringView view, const char* b) {
+ return view.size == strlen(b) && memcmp(view.data, b, view.size) == 0;
+}
+
+static int count_exts_in_msg(const google_protobuf_DescriptorProto* msg_proto) {
+ size_t n;
+ google_protobuf_DescriptorProto_extension(msg_proto, &n);
+ int ext_count = n;
+
+ const google_protobuf_DescriptorProto* const* nested_msgs =
+ google_protobuf_DescriptorProto_nested_type(msg_proto, &n);
+ for (size_t i = 0; i < n; i++) {
+ ext_count += count_exts_in_msg(nested_msgs[i]);
+ }
+
+ return ext_count;
+}
+
+// Allocate and initialize one file def, and add it to the context object.
+void _upb_FileDef_Create(upb_DefBuilder* ctx,
+ const google_protobuf_FileDescriptorProto* file_proto) {
+ upb_FileDef* file = _upb_DefBuilder_Alloc(ctx, sizeof(upb_FileDef));
+ ctx->file = file;
+
+ const google_protobuf_DescriptorProto* const* msgs;
+ const google_protobuf_EnumDescriptorProto* const* enums;
+ const google_protobuf_FieldDescriptorProto* const* exts;
+ const google_protobuf_ServiceDescriptorProto* const* services;
+ const upb_StringView* strs;
+ const int32_t* public_deps;
+ const int32_t* weak_deps;
+ size_t n;
+
+ file->symtab = ctx->symtab;
+
+ // Count all extensions in the file, to build a flat array of layouts.
+ google_protobuf_FileDescriptorProto_extension(file_proto, &n);
+ int ext_count = n;
+ msgs = google_protobuf_FileDescriptorProto_message_type(file_proto, &n);
+ for (int i = 0; i < n; i++) {
+ ext_count += count_exts_in_msg(msgs[i]);
+ }
+ file->ext_count = ext_count;
+
+ if (ctx->layout) {
+ // We are using the ext layouts that were passed in.
+ file->ext_layouts = ctx->layout->exts;
+ if (ctx->layout->ext_count != file->ext_count) {
+ _upb_DefBuilder_Errf(ctx,
+ "Extension count did not match layout (%d vs %d)",
+ ctx->layout->ext_count, file->ext_count);
+ }
+ } else {
+ // We are building ext layouts from scratch.
+ file->ext_layouts = _upb_DefBuilder_Alloc(
+ ctx, sizeof(*file->ext_layouts) * file->ext_count);
+ upb_MiniTable_Extension* ext =
+ _upb_DefBuilder_Alloc(ctx, sizeof(*ext) * file->ext_count);
+ for (int i = 0; i < file->ext_count; i++) {
+ file->ext_layouts[i] = &ext[i];
+ }
+ }
+
+ if (!google_protobuf_FileDescriptorProto_has_name(file_proto)) {
+ _upb_DefBuilder_Errf(ctx, "File has no name");
+ }
+
+ file->name = strviewdup(ctx, google_protobuf_FileDescriptorProto_name(file_proto));
+
+ upb_StringView package = google_protobuf_FileDescriptorProto_package(file_proto);
+ if (package.size) {
+ _upb_DefBuilder_CheckIdentFull(ctx, package);
+ file->package = strviewdup(ctx, package);
+ } else {
+ file->package = NULL;
+ }
+
+ if (google_protobuf_FileDescriptorProto_has_syntax(file_proto)) {
+ upb_StringView syntax = google_protobuf_FileDescriptorProto_syntax(file_proto);
+
+ if (streql_view(syntax, "proto2")) {
+ file->syntax = kUpb_Syntax_Proto2;
+ } else if (streql_view(syntax, "proto3")) {
+ file->syntax = kUpb_Syntax_Proto3;
+ } else {
+ _upb_DefBuilder_Errf(ctx, "Invalid syntax '" UPB_STRINGVIEW_FORMAT "'",
+ UPB_STRINGVIEW_ARGS(syntax));
+ }
+ } else {
+ file->syntax = kUpb_Syntax_Proto2;
+ }
+
+ // Read options.
+ UBP_DEF_SET_OPTIONS(file->opts, FileDescriptorProto, FileOptions, file_proto);
+
+ // Verify dependencies.
+ strs = google_protobuf_FileDescriptorProto_dependency(file_proto, &n);
+ file->dep_count = n;
+ file->deps = _upb_DefBuilder_Alloc(ctx, sizeof(*file->deps) * n);
+
+ for (size_t i = 0; i < n; i++) {
+ upb_StringView str = strs[i];
+ file->deps[i] =
+ upb_DefPool_FindFileByNameWithSize(ctx->symtab, str.data, str.size);
+ if (!file->deps[i]) {
+ _upb_DefBuilder_Errf(ctx,
+ "Depends on file '" UPB_STRINGVIEW_FORMAT
+ "', but it has not been loaded",
+ UPB_STRINGVIEW_ARGS(str));
+ }
+ }
+
+ public_deps = google_protobuf_FileDescriptorProto_public_dependency(file_proto, &n);
+ file->public_dep_count = n;
+ file->public_deps =
+ _upb_DefBuilder_Alloc(ctx, sizeof(*file->public_deps) * n);
+ int32_t* mutable_public_deps = (int32_t*)file->public_deps;
+ for (size_t i = 0; i < n; i++) {
+ if (public_deps[i] >= file->dep_count) {
+ _upb_DefBuilder_Errf(ctx, "public_dep %d is out of range",
+ (int)public_deps[i]);
+ }
+ mutable_public_deps[i] = public_deps[i];
+ }
+
+ weak_deps = google_protobuf_FileDescriptorProto_weak_dependency(file_proto, &n);
+ file->weak_dep_count = n;
+ file->weak_deps = _upb_DefBuilder_Alloc(ctx, sizeof(*file->weak_deps) * n);
+ int32_t* mutable_weak_deps = (int32_t*)file->weak_deps;
+ for (size_t i = 0; i < n; i++) {
+ if (weak_deps[i] >= file->dep_count) {
+ _upb_DefBuilder_Errf(ctx, "weak_dep %d is out of range",
+ (int)weak_deps[i]);
+ }
+ mutable_weak_deps[i] = weak_deps[i];
+ }
+
+ // Create enums.
+ enums = google_protobuf_FileDescriptorProto_enum_type(file_proto, &n);
+ file->top_lvl_enum_count = n;
+ file->top_lvl_enums = _upb_EnumDefs_New(ctx, n, enums, NULL);
+
+ // Create extensions.
+ exts = google_protobuf_FileDescriptorProto_extension(file_proto, &n);
+ file->top_lvl_ext_count = n;
+ file->top_lvl_exts =
+ _upb_FieldDefs_New(ctx, n, exts, file->package, NULL, NULL);
+
+ // Create messages.
+ msgs = google_protobuf_FileDescriptorProto_message_type(file_proto, &n);
+ file->top_lvl_msg_count = n;
+ file->top_lvl_msgs = _upb_MessageDefs_New(ctx, n, msgs, NULL);
+
+ // Create services.
+ services = google_protobuf_FileDescriptorProto_service(file_proto, &n);
+ file->service_count = n;
+ file->services = _upb_ServiceDefs_New(ctx, n, services);
+
+ // Now that all names are in the table, build layouts and resolve refs.
+
+ for (int i = 0; i < file->top_lvl_msg_count; i++) {
+ upb_MessageDef* m = (upb_MessageDef*)upb_FileDef_TopLevelMessage(file, i);
+ _upb_MessageDef_Resolve(ctx, m);
+ }
+
+ for (int i = 0; i < file->top_lvl_ext_count; i++) {
+ upb_FieldDef* f = (upb_FieldDef*)upb_FileDef_TopLevelExtension(file, i);
+ _upb_FieldDef_Resolve(ctx, file->package, f);
+ }
+
+ if (!ctx->layout) {
+ for (int i = 0; i < file->top_lvl_msg_count; i++) {
+ upb_MessageDef* m = (upb_MessageDef*)upb_FileDef_TopLevelMessage(file, i);
+ _upb_MessageDef_LinkMiniTable(ctx, m);
+ }
+ }
+
+ if (file->ext_count) {
+ bool ok = _upb_extreg_add(_upb_DefPool_ExtReg(ctx->symtab),
+ file->ext_layouts, file->ext_count);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+ }
+}
+
+
+#include <string.h>
+
+
+// Must be last.
+
+static size_t get_field_size(const upb_MiniTable_Field* f) {
+ static unsigned char sizes[] = {
+ 0, /* 0 */
+ 8, /* kUpb_FieldType_Double */
+ 4, /* kUpb_FieldType_Float */
+ 8, /* kUpb_FieldType_Int64 */
+ 8, /* kUpb_FieldType_UInt64 */
+ 4, /* kUpb_FieldType_Int32 */
+ 8, /* kUpb_FieldType_Fixed64 */
+ 4, /* kUpb_FieldType_Fixed32 */
+ 1, /* kUpb_FieldType_Bool */
+ sizeof(upb_StringView), /* kUpb_FieldType_String */
+ sizeof(void*), /* kUpb_FieldType_Group */
+ sizeof(void*), /* kUpb_FieldType_Message */
+ sizeof(upb_StringView), /* kUpb_FieldType_Bytes */
+ 4, /* kUpb_FieldType_UInt32 */
+ 4, /* kUpb_FieldType_Enum */
+ 4, /* kUpb_FieldType_SFixed32 */
+ 8, /* kUpb_FieldType_SFixed64 */
+ 4, /* kUpb_FieldType_SInt32 */
+ 8, /* kUpb_FieldType_SInt64 */
+ };
+ return upb_IsRepeatedOrMap(f) ? sizeof(void*) : sizes[f->descriptortype];
+}
+
+upb_Message* upb_Message_New(const upb_MessageDef* m, upb_Arena* a) {
+ return _upb_Message_New(upb_MessageDef_MiniTable(m), a);
+}
+
+static bool in_oneof(const upb_MiniTable_Field* field) {
+ return field->presence < 0;
+}
+
+static upb_MessageValue _upb_Message_Getraw(const upb_Message* msg,
+ const upb_FieldDef* f) {
+ const upb_MiniTable_Field* field = upb_FieldDef_MiniTable(f);
+ const char* mem = UPB_PTR_AT(msg, field->offset, char);
+ upb_MessageValue val = {0};
+ memcpy(&val, mem, get_field_size(field));
+ return val;
+}
+
+bool upb_Message_Has(const upb_Message* msg, const upb_FieldDef* f) {
+ assert(upb_FieldDef_HasPresence(f));
+ if (upb_FieldDef_IsExtension(f)) {
+ const upb_MiniTable_Extension* ext = _upb_FieldDef_ExtensionMiniTable(f);
+ return _upb_Message_Getext(msg, ext) != NULL;
+ } else {
+ const upb_MiniTable_Field* field = upb_FieldDef_MiniTable(f);
+ if (in_oneof(field)) {
+ return _upb_getoneofcase_field(msg, field) == field->number;
+ } else if (field->presence > 0) {
+ return _upb_hasbit_field(msg, field);
+ } else {
+ UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
+ field->descriptortype == kUpb_FieldType_Group);
+ return _upb_Message_Getraw(msg, f).msg_val != NULL;
+ }
+ }
+}
+
+const upb_FieldDef* upb_Message_WhichOneof(const upb_Message* msg,
+ const upb_OneofDef* o) {
+ const upb_FieldDef* f = upb_OneofDef_Field(o, 0);
+ if (upb_OneofDef_IsSynthetic(o)) {
+ UPB_ASSERT(upb_OneofDef_FieldCount(o) == 1);
+ return upb_Message_Has(msg, f) ? f : NULL;
+ } else {
+ const upb_MiniTable_Field* field = upb_FieldDef_MiniTable(f);
+ uint32_t oneof_case = _upb_getoneofcase_field(msg, field);
+ f = oneof_case ? upb_OneofDef_LookupNumber(o, oneof_case) : NULL;
+ UPB_ASSERT((f != NULL) == (oneof_case != 0));
+ return f;
+ }
+}
+
+upb_MessageValue upb_Message_Get(const upb_Message* msg,
+ const upb_FieldDef* f) {
+ if (upb_FieldDef_IsExtension(f)) {
+ const upb_Message_Extension* ext =
+ _upb_Message_Getext(msg, _upb_FieldDef_ExtensionMiniTable(f));
+ if (ext) {
+ upb_MessageValue val;
+ memcpy(&val, &ext->data, sizeof(val));
+ return val;
+ } else if (upb_FieldDef_IsRepeated(f)) {
+ return (upb_MessageValue){.array_val = NULL};
+ }
+ } else if (!upb_FieldDef_HasPresence(f) || upb_Message_Has(msg, f)) {
+ return _upb_Message_Getraw(msg, f);
+ }
+ return upb_FieldDef_Default(f);
+}
+
+upb_MutableMessageValue upb_Message_Mutable(upb_Message* msg,
+ const upb_FieldDef* f,
+ upb_Arena* a) {
+ UPB_ASSERT(upb_FieldDef_IsSubMessage(f) || upb_FieldDef_IsRepeated(f));
+ if (upb_FieldDef_HasPresence(f) && !upb_Message_Has(msg, f)) {
+ // We need to skip the upb_Message_Get() call in this case.
+ goto make;
+ }
+
+ upb_MessageValue val = upb_Message_Get(msg, f);
+ if (val.array_val) {
+ return (upb_MutableMessageValue){.array = (upb_Array*)val.array_val};
+ }
+
+ upb_MutableMessageValue ret;
+make:
+ if (!a) return (upb_MutableMessageValue){.array = NULL};
+ if (upb_FieldDef_IsMap(f)) {
+ const upb_MessageDef* entry = upb_FieldDef_MessageSubDef(f);
+ const upb_FieldDef* key =
+ upb_MessageDef_FindFieldByNumber(entry, kUpb_MapEntry_KeyFieldNumber);
+ const upb_FieldDef* value =
+ upb_MessageDef_FindFieldByNumber(entry, kUpb_MapEntry_ValueFieldNumber);
+ ret.map =
+ upb_Map_New(a, upb_FieldDef_CType(key), upb_FieldDef_CType(value));
+ } else if (upb_FieldDef_IsRepeated(f)) {
+ ret.array = upb_Array_New(a, upb_FieldDef_CType(f));
+ } else {
+ UPB_ASSERT(upb_FieldDef_IsSubMessage(f));
+ ret.msg = upb_Message_New(upb_FieldDef_MessageSubDef(f), a);
+ }
+
+ val.array_val = ret.array;
+ upb_Message_Set(msg, f, val, a);
+
+ return ret;
+}
+
+bool upb_Message_Set(upb_Message* msg, const upb_FieldDef* f,
+ upb_MessageValue val, upb_Arena* a) {
+ if (upb_FieldDef_IsExtension(f)) {
+ upb_Message_Extension* ext = _upb_Message_GetOrCreateExtension(
+ msg, _upb_FieldDef_ExtensionMiniTable(f), a);
+ if (!ext) return false;
+ memcpy(&ext->data, &val, sizeof(val));
+ } else {
+ const upb_MiniTable_Field* field = upb_FieldDef_MiniTable(f);
+
+ // Building reflection should always cause all sub-message types to be
+ // linked, but double-check here just for extra assurance.
+ UPB_ASSERT(!upb_FieldDef_IsSubMessage(f) ||
+ upb_MessageDef_MiniTable(upb_FieldDef_ContainingType(f))
+ ->subs[field->submsg_index]
+ .submsg);
+
+ char* mem = UPB_PTR_AT(msg, field->offset, char);
+ memcpy(mem, &val, get_field_size(field));
+ if (field->presence > 0) {
+ _upb_sethas_field(msg, field);
+ } else if (in_oneof(field)) {
+ *_upb_oneofcase_field(msg, field) = field->number;
+ }
+ }
+ return true;
+}
+
+void upb_Message_ClearField(upb_Message* msg, const upb_FieldDef* f) {
+ if (upb_FieldDef_IsExtension(f)) {
+ _upb_Message_Clearext(msg, _upb_FieldDef_ExtensionMiniTable(f));
+ } else {
+ const upb_MiniTable_Field* field = upb_FieldDef_MiniTable(f);
+ char* mem = UPB_PTR_AT(msg, field->offset, char);
+
+ if (field->presence > 0) {
+ _upb_clearhas_field(msg, field);
+ } else if (in_oneof(field)) {
+ uint32_t* oneof_case = _upb_oneofcase_field(msg, field);
+ if (*oneof_case != field->number) return;
+ *oneof_case = 0;
+ }
+
+ memset(mem, 0, get_field_size(field));
+ }
+}
+
+void upb_Message_Clear(upb_Message* msg, const upb_MessageDef* m) {
+ _upb_Message_Clear(msg, upb_MessageDef_MiniTable(m));
+}
+
+bool upb_Message_Next(const upb_Message* msg, const upb_MessageDef* m,
+ const upb_DefPool* ext_pool, const upb_FieldDef** out_f,
+ upb_MessageValue* out_val, size_t* iter) {
+ size_t i = *iter;
+ size_t n = upb_MessageDef_FieldCount(m);
+ const upb_MessageValue zero = {0};
+ UPB_UNUSED(ext_pool);
+
+ /* Iterate over normal fields, returning the first one that is set. */
+ while (++i < n) {
+ const upb_FieldDef* f = upb_MessageDef_Field(m, i);
+ upb_MessageValue val = _upb_Message_Getraw(msg, f);
+
+ /* Skip field if unset or empty. */
+ if (upb_FieldDef_HasPresence(f)) {
+ if (!upb_Message_Has(msg, f)) continue;
+ } else {
+ upb_MessageValue test = val;
+ if (upb_FieldDef_IsString(f) && !upb_FieldDef_IsRepeated(f)) {
+ /* Clear string pointer, only size matters (ptr could be non-NULL). */
+ test.str_val.data = NULL;
+ }
+ /* Continue if NULL or 0. */
+ if (memcmp(&test, &zero, sizeof(test)) == 0) continue;
+
+ /* Continue on empty array or map. */
+ if (upb_FieldDef_IsMap(f)) {
+ if (upb_Map_Size(test.map_val) == 0) continue;
+ } else if (upb_FieldDef_IsRepeated(f)) {
+ if (upb_Array_Size(test.array_val) == 0) continue;
+ }
+ }
+
+ *out_val = val;
+ *out_f = f;
+ *iter = i;
+ return true;
+ }
+
+ if (ext_pool) {
+ /* Return any extensions that are set. */
+ size_t count;
+ const upb_Message_Extension* ext = _upb_Message_Getexts(msg, &count);
+ if (i - n < count) {
+ ext += count - 1 - (i - n);
+ memcpy(out_val, &ext->data, sizeof(*out_val));
+ *out_f = _upb_DefPool_FindExtensionByMiniTable(ext_pool, ext->ext);
+ *iter = i;
+ return true;
+ }
+ }
+
+ *iter = i;
+ return false;
+}
+
+bool _upb_Message_DiscardUnknown(upb_Message* msg, const upb_MessageDef* m,
+ int depth) {
+ size_t iter = kUpb_Message_Begin;
+ const upb_FieldDef* f;
+ upb_MessageValue val;
+ bool ret = true;
+
+ if (--depth == 0) return false;
+
+ _upb_Message_DiscardUnknown_shallow(msg);
+
+ while (upb_Message_Next(msg, m, NULL /*ext_pool*/, &f, &val, &iter)) {
+ const upb_MessageDef* subm = upb_FieldDef_MessageSubDef(f);
+ if (!subm) continue;
+ if (upb_FieldDef_IsMap(f)) {
+ const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(subm, 2);
+ const upb_MessageDef* val_m = upb_FieldDef_MessageSubDef(val_f);
+ upb_Map* map = (upb_Map*)val.map_val;
+ size_t iter = kUpb_Map_Begin;
+
+ if (!val_m) continue;
+
+ while (upb_MapIterator_Next(map, &iter)) {
+ upb_MessageValue map_val = upb_MapIterator_Value(map, iter);
+ if (!_upb_Message_DiscardUnknown((upb_Message*)map_val.msg_val, val_m,
+ depth)) {
+ ret = false;
+ }
+ }
+ } else if (upb_FieldDef_IsRepeated(f)) {
+ const upb_Array* arr = val.array_val;
+ size_t i, n = upb_Array_Size(arr);
+ for (i = 0; i < n; i++) {
+ upb_MessageValue elem = upb_Array_Get(arr, i);
+ if (!_upb_Message_DiscardUnknown((upb_Message*)elem.msg_val, subm,
+ depth)) {
+ ret = false;
+ }
+ }
+ } else {
+ if (!_upb_Message_DiscardUnknown((upb_Message*)val.msg_val, subm,
+ depth)) {
+ ret = false;
+ }
+ }
+ }
+
+ return ret;
+}
+
+bool upb_Message_DiscardUnknown(upb_Message* msg, const upb_MessageDef* m,
+ int maxdepth) {
+ return _upb_Message_DiscardUnknown(msg, m, maxdepth);
+}
+
+
+
+// Must be last.
+
+struct upb_MessageDef {
+ const google_protobuf_MessageOptions* opts;
+ const upb_MiniTable* layout;
+ const upb_FileDef* file;
+ const upb_MessageDef* containing_type;
+ const char* full_name;
+
+ // Tables for looking up fields by number and name.
+ upb_inttable itof;
+ upb_strtable ntof;
+
+ /* All nested defs.
+ * MEM: We could save some space here by putting nested defs in a contiguous
+ * region and calculating counts from offsets or vice-versa. */
+ const upb_FieldDef* fields;
+ const upb_OneofDef* oneofs;
+ const upb_ExtensionRange* ext_ranges;
+ const upb_MessageDef* nested_msgs;
+ const upb_EnumDef* nested_enums;
+ const upb_FieldDef* nested_exts;
+ int field_count;
+ int real_oneof_count;
+ int oneof_count;
+ int ext_range_count;
+ int nested_msg_count;
+ int nested_enum_count;
+ int nested_ext_count;
+ bool in_message_set;
+ bool is_sorted;
+ upb_WellKnown well_known_type;
+#if UINTPTR_MAX == 0xffffffff
+ uint32_t padding; // Increase size to a multiple of 8.
+#endif
+};
+
+static void assign_msg_wellknowntype(upb_MessageDef* m) {
+ const char* name = upb_MessageDef_FullName(m);
+ if (name == NULL) {
+ m->well_known_type = kUpb_WellKnown_Unspecified;
+ return;
+ }
+ if (!strcmp(name, "google.protobuf.Any")) {
+ m->well_known_type = kUpb_WellKnown_Any;
+ } else if (!strcmp(name, "google.protobuf.FieldMask")) {
+ m->well_known_type = kUpb_WellKnown_FieldMask;
+ } else if (!strcmp(name, "google.protobuf.Duration")) {
+ m->well_known_type = kUpb_WellKnown_Duration;
+ } else if (!strcmp(name, "google.protobuf.Timestamp")) {
+ m->well_known_type = kUpb_WellKnown_Timestamp;
+ } else if (!strcmp(name, "google.protobuf.DoubleValue")) {
+ m->well_known_type = kUpb_WellKnown_DoubleValue;
+ } else if (!strcmp(name, "google.protobuf.FloatValue")) {
+ m->well_known_type = kUpb_WellKnown_FloatValue;
+ } else if (!strcmp(name, "google.protobuf.Int64Value")) {
+ m->well_known_type = kUpb_WellKnown_Int64Value;
+ } else if (!strcmp(name, "google.protobuf.UInt64Value")) {
+ m->well_known_type = kUpb_WellKnown_UInt64Value;
+ } else if (!strcmp(name, "google.protobuf.Int32Value")) {
+ m->well_known_type = kUpb_WellKnown_Int32Value;
+ } else if (!strcmp(name, "google.protobuf.UInt32Value")) {
+ m->well_known_type = kUpb_WellKnown_UInt32Value;
+ } else if (!strcmp(name, "google.protobuf.BoolValue")) {
+ m->well_known_type = kUpb_WellKnown_BoolValue;
+ } else if (!strcmp(name, "google.protobuf.StringValue")) {
+ m->well_known_type = kUpb_WellKnown_StringValue;
+ } else if (!strcmp(name, "google.protobuf.BytesValue")) {
+ m->well_known_type = kUpb_WellKnown_BytesValue;
+ } else if (!strcmp(name, "google.protobuf.Value")) {
+ m->well_known_type = kUpb_WellKnown_Value;
+ } else if (!strcmp(name, "google.protobuf.ListValue")) {
+ m->well_known_type = kUpb_WellKnown_ListValue;
+ } else if (!strcmp(name, "google.protobuf.Struct")) {
+ m->well_known_type = kUpb_WellKnown_Struct;
+ } else {
+ m->well_known_type = kUpb_WellKnown_Unspecified;
+ }
+}
+
+upb_MessageDef* _upb_MessageDef_At(const upb_MessageDef* m, int i) {
+ return (upb_MessageDef*)&m[i];
+}
+
+bool _upb_MessageDef_IsValidExtensionNumber(const upb_MessageDef* m, int n) {
+ for (int i = 0; i < m->ext_range_count; i++) {
+ const upb_ExtensionRange* r = upb_MessageDef_ExtensionRange(m, i);
+ if (upb_ExtensionRange_Start(r) <= n && n < upb_ExtensionRange_End(r)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+const google_protobuf_MessageOptions* upb_MessageDef_Options(
+ const upb_MessageDef* m) {
+ return m->opts;
+}
+
+bool upb_MessageDef_HasOptions(const upb_MessageDef* m) {
+ return m->opts != (void*)kUpbDefOptDefault;
+}
+
+const char* upb_MessageDef_FullName(const upb_MessageDef* m) {
+ return m->full_name;
+}
+
+const upb_FileDef* upb_MessageDef_File(const upb_MessageDef* m) {
+ return m->file;
+}
+
+const upb_MessageDef* upb_MessageDef_ContainingType(const upb_MessageDef* m) {
+ return m->containing_type;
+}
+
+const char* upb_MessageDef_Name(const upb_MessageDef* m) {
+ return _upb_DefBuilder_FullToShort(m->full_name);
+}
+
+upb_Syntax upb_MessageDef_Syntax(const upb_MessageDef* m) {
+ return upb_FileDef_Syntax(m->file);
+}
+
+const upb_FieldDef* upb_MessageDef_FindFieldByNumber(const upb_MessageDef* m,
+ uint32_t i) {
+ upb_value val;
+ return upb_inttable_lookup(&m->itof, i, &val) ? upb_value_getconstptr(val)
+ : NULL;
+}
+
+const upb_FieldDef* upb_MessageDef_FindFieldByNameWithSize(
+ const upb_MessageDef* m, const char* name, size_t size) {
+ upb_value val;
+
+ if (!upb_strtable_lookup2(&m->ntof, name, size, &val)) {
+ return NULL;
+ }
+
+ return _upb_DefType_Unpack(val, UPB_DEFTYPE_FIELD);
+}
+
+const upb_OneofDef* upb_MessageDef_FindOneofByNameWithSize(
+ const upb_MessageDef* m, const char* name, size_t size) {
+ upb_value val;
+
+ if (!upb_strtable_lookup2(&m->ntof, name, size, &val)) {
+ return NULL;
+ }
+
+ return _upb_DefType_Unpack(val, UPB_DEFTYPE_ONEOF);
+}
+
+bool _upb_MessageDef_Insert(upb_MessageDef* m, const char* name, size_t len,
+ upb_value v, upb_Arena* a) {
+ return upb_strtable_insert(&m->ntof, name, len, v, a);
+}
+
+bool upb_MessageDef_FindByNameWithSize(const upb_MessageDef* m,
+ const char* name, size_t len,
+ const upb_FieldDef** out_f,
+ const upb_OneofDef** out_o) {
+ upb_value val;
+
+ if (!upb_strtable_lookup2(&m->ntof, name, len, &val)) {
+ return false;
+ }
+
+ const upb_FieldDef* f = _upb_DefType_Unpack(val, UPB_DEFTYPE_FIELD);
+ const upb_OneofDef* o = _upb_DefType_Unpack(val, UPB_DEFTYPE_ONEOF);
+ if (out_f) *out_f = f;
+ if (out_o) *out_o = o;
+ return f || o; /* False if this was a JSON name. */
+}
+
+const upb_FieldDef* upb_MessageDef_FindByJsonNameWithSize(
+ const upb_MessageDef* m, const char* name, size_t size) {
+ upb_value val;
+ const upb_FieldDef* f;
+
+ if (!upb_strtable_lookup2(&m->ntof, name, size, &val)) {
+ return NULL;
+ }
+
+ f = _upb_DefType_Unpack(val, UPB_DEFTYPE_FIELD);
+ if (!f) f = _upb_DefType_Unpack(val, UPB_DEFTYPE_FIELD_JSONNAME);
+
+ return f;
+}
+
+int upb_MessageDef_ExtensionRangeCount(const upb_MessageDef* m) {
+ return m->ext_range_count;
+}
+
+int upb_MessageDef_FieldCount(const upb_MessageDef* m) {
+ return m->field_count;
+}
+
+int upb_MessageDef_OneofCount(const upb_MessageDef* m) {
+ return m->oneof_count;
+}
+
+int upb_MessageDef_NestedMessageCount(const upb_MessageDef* m) {
+ return m->nested_msg_count;
+}
+
+int upb_MessageDef_NestedEnumCount(const upb_MessageDef* m) {
+ return m->nested_enum_count;
+}
+
+int upb_MessageDef_NestedExtensionCount(const upb_MessageDef* m) {
+ return m->nested_ext_count;
+}
+
+const upb_MiniTable* upb_MessageDef_MiniTable(const upb_MessageDef* m) {
+ return m->layout;
+}
+
+const upb_ExtensionRange* upb_MessageDef_ExtensionRange(const upb_MessageDef* m,
+ int i) {
+ UPB_ASSERT(0 <= i && i < m->ext_range_count);
+ return _upb_ExtensionRange_At(m->ext_ranges, i);
+}
+
+const upb_FieldDef* upb_MessageDef_Field(const upb_MessageDef* m, int i) {
+ UPB_ASSERT(0 <= i && i < m->field_count);
+ return _upb_FieldDef_At(m->fields, i);
+}
+
+const upb_OneofDef* upb_MessageDef_Oneof(const upb_MessageDef* m, int i) {
+ UPB_ASSERT(0 <= i && i < m->oneof_count);
+ return _upb_OneofDef_At(m->oneofs, i);
+}
+
+const upb_MessageDef* upb_MessageDef_NestedMessage(const upb_MessageDef* m,
+ int i) {
+ UPB_ASSERT(0 <= i && i < m->nested_msg_count);
+ return &m->nested_msgs[i];
+}
+
+const upb_EnumDef* upb_MessageDef_NestedEnum(const upb_MessageDef* m, int i) {
+ UPB_ASSERT(0 <= i && i < m->nested_enum_count);
+ return _upb_EnumDef_At(m->nested_enums, i);
+}
+
+const upb_FieldDef* upb_MessageDef_NestedExtension(const upb_MessageDef* m,
+ int i) {
+ UPB_ASSERT(0 <= i && i < m->nested_ext_count);
+ return _upb_FieldDef_At(m->nested_exts, i);
+}
+
+upb_WellKnown upb_MessageDef_WellKnownType(const upb_MessageDef* m) {
+ return m->well_known_type;
+}
+
+bool _upb_MessageDef_InMessageSet(const upb_MessageDef* m) {
+ return m->in_message_set;
+}
+
+const upb_FieldDef* upb_MessageDef_FindFieldByName(const upb_MessageDef* m,
+ const char* name) {
+ return upb_MessageDef_FindFieldByNameWithSize(m, name, strlen(name));
+}
+
+const upb_OneofDef* upb_MessageDef_FindOneofByName(const upb_MessageDef* m,
+ const char* name) {
+ return upb_MessageDef_FindOneofByNameWithSize(m, name, strlen(name));
+}
+
+bool upb_MessageDef_IsMapEntry(const upb_MessageDef* m) {
+ return google_protobuf_MessageOptions_map_entry(upb_MessageDef_Options(m));
+}
+
+bool upb_MessageDef_IsMessageSet(const upb_MessageDef* m) {
+ return google_protobuf_MessageOptions_message_set_wire_format(
+ upb_MessageDef_Options(m));
+}
+
+static upb_MiniTable* _upb_MessageDef_MakeMiniTable(upb_DefBuilder* ctx,
+ const upb_MessageDef* m) {
+ if (google_protobuf_MessageOptions_message_set_wire_format(m->opts)) {
+ return upb_MiniTable_BuildMessageSet(kUpb_MiniTablePlatform_Native,
+ ctx->arena);
+ }
+
+ if (upb_MessageDef_IsMapEntry(m)) {
+ if (m->field_count != 2) {
+ _upb_DefBuilder_Errf(ctx, "invalid map (%s)", m->full_name);
+ }
+
+ const upb_FieldDef* f0 = upb_MessageDef_Field(m, 0);
+ const upb_FieldDef* f1 = upb_MessageDef_Field(m, 1);
+ const upb_FieldType t0 = upb_FieldDef_Type(f0);
+ const upb_FieldType t1 = upb_FieldDef_Type(f1);
+
+ const bool is_proto3_enum =
+ (t1 == kUpb_FieldType_Enum) && !_upb_FieldDef_IsClosedEnum(f1);
+ UPB_ASSERT(_upb_FieldDef_LayoutIndex(f0) == 0);
+ UPB_ASSERT(_upb_FieldDef_LayoutIndex(f1) == 1);
+
+ return upb_MiniTable_BuildMapEntry(
+ t0, t1, is_proto3_enum, kUpb_MiniTablePlatform_Native, ctx->arena);
+ }
+
+ upb_StringView desc;
+ bool ok = upb_MessageDef_MiniDescriptorEncode(m, ctx->tmp_arena, &desc);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+
+ void** scratch_data = _upb_DefPool_ScratchData(ctx->symtab);
+ size_t* scratch_size = _upb_DefPool_ScratchSize(ctx->symtab);
+ upb_MiniTable* ret = upb_MiniTable_BuildWithBuf(
+ desc.data, desc.size, kUpb_MiniTablePlatform_Native, ctx->arena,
+ scratch_data, scratch_size, ctx->status);
+ if (!ret) _upb_DefBuilder_FailJmp(ctx);
+ return ret;
+}
+
+void _upb_MessageDef_Resolve(upb_DefBuilder* ctx, upb_MessageDef* m) {
+ for (int i = 0; i < m->field_count; i++) {
+ upb_FieldDef* f = (upb_FieldDef*)upb_MessageDef_Field(m, i);
+ _upb_FieldDef_Resolve(ctx, upb_MessageDef_FullName(m), f);
+ }
+
+ if (!ctx->layout) {
+ m->layout = _upb_MessageDef_MakeMiniTable(ctx, m);
+ if (!m->layout) _upb_DefBuilder_OomErr(ctx);
+ }
+
+ m->in_message_set = false;
+ for (int i = 0; i < upb_MessageDef_NestedExtensionCount(m); i++) {
+ upb_FieldDef* ext = (upb_FieldDef*)upb_MessageDef_NestedExtension(m, i);
+ _upb_FieldDef_Resolve(ctx, upb_MessageDef_FullName(m), ext);
+ if (upb_FieldDef_Type(ext) == kUpb_FieldType_Message &&
+ upb_FieldDef_Label(ext) == kUpb_Label_Optional &&
+ upb_FieldDef_MessageSubDef(ext) == m &&
+ google_protobuf_MessageOptions_message_set_wire_format(
+ upb_MessageDef_Options(upb_FieldDef_ContainingType(ext)))) {
+ m->in_message_set = true;
+ }
+ }
+
+ for (int i = 0; i < upb_MessageDef_NestedMessageCount(m); i++) {
+ upb_MessageDef* n = (upb_MessageDef*)upb_MessageDef_NestedMessage(m, i);
+ _upb_MessageDef_Resolve(ctx, n);
+ }
+}
+
+void _upb_MessageDef_InsertField(upb_DefBuilder* ctx, upb_MessageDef* m,
+ const upb_FieldDef* f) {
+ const int32_t field_number = upb_FieldDef_Number(f);
+
+ if (field_number <= 0 || field_number > kUpb_MaxFieldNumber) {
+ _upb_DefBuilder_Errf(ctx, "invalid field number (%u)", field_number);
+ }
+
+ const char* json_name = upb_FieldDef_JsonName(f);
+ const char* shortname = upb_FieldDef_Name(f);
+ const size_t shortnamelen = strlen(shortname);
+
+ upb_value v = upb_value_constptr(f);
+
+ upb_value existing_v;
+ if (upb_strtable_lookup(&m->ntof, shortname, &existing_v)) {
+ _upb_DefBuilder_Errf(ctx, "duplicate field name (%s)", shortname);
+ }
+
+ const upb_value field_v = _upb_DefType_Pack(f, UPB_DEFTYPE_FIELD);
+ bool ok =
+ _upb_MessageDef_Insert(m, shortname, shortnamelen, field_v, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+
+ if (strcmp(shortname, json_name) != 0) {
+ if (upb_strtable_lookup(&m->ntof, json_name, &v)) {
+ _upb_DefBuilder_Errf(ctx, "duplicate json_name (%s)", json_name);
+ }
+
+ const size_t json_size = strlen(json_name);
+ const upb_value json_v = _upb_DefType_Pack(f, UPB_DEFTYPE_FIELD_JSONNAME);
+ ok = _upb_MessageDef_Insert(m, json_name, json_size, json_v, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+ }
+
+ if (upb_inttable_lookup(&m->itof, field_number, NULL)) {
+ _upb_DefBuilder_Errf(ctx, "duplicate field number (%u)", field_number);
+ }
+
+ ok = upb_inttable_insert(&m->itof, field_number, v, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+}
+
+void _upb_MessageDef_LinkMiniTable(upb_DefBuilder* ctx,
+ const upb_MessageDef* m) {
+ for (int i = 0; i < m->field_count; i++) {
+ const upb_FieldDef* f = upb_MessageDef_Field(m, i);
+ const upb_MessageDef* sub_m = upb_FieldDef_MessageSubDef(f);
+ const upb_EnumDef* sub_e = upb_FieldDef_EnumSubDef(f);
+ const int layout_index = _upb_FieldDef_LayoutIndex(f);
+ upb_MiniTable* mt = (upb_MiniTable*)upb_MessageDef_MiniTable(m);
+
+ UPB_ASSERT(layout_index < m->field_count);
+ upb_MiniTable_Field* mt_f =
+ (upb_MiniTable_Field*)&m->layout->fields[layout_index];
+ if (sub_m) {
+ if (!mt->subs) {
+ _upb_DefBuilder_Errf(ctx, "invalid submsg for (%s)", m->full_name);
+ }
+ UPB_ASSERT(mt_f);
+ UPB_ASSERT(sub_m->layout);
+ upb_MiniTable_SetSubMessage(mt, mt_f, sub_m->layout);
+ } else if (_upb_FieldDef_IsClosedEnum(f)) {
+ upb_MiniTable_SetSubEnum(mt, mt_f, _upb_EnumDef_MiniTable(sub_e));
+ }
+ }
+
+ for (int i = 0; i < m->nested_msg_count; i++) {
+ _upb_MessageDef_LinkMiniTable(ctx, upb_MessageDef_NestedMessage(m, i));
+ }
+}
+
+static uint64_t _upb_MessageDef_Modifiers(const upb_MessageDef* m) {
+ uint64_t out = 0;
+ if (upb_FileDef_Syntax(m->file) == kUpb_Syntax_Proto3) {
+ out |= kUpb_MessageModifier_ValidateUtf8;
+ out |= kUpb_MessageModifier_DefaultIsPacked;
+ }
+ if (m->ext_range_count) {
+ out |= kUpb_MessageModifier_IsExtendable;
+ }
+ return out;
+}
+
+bool upb_MessageDef_MiniDescriptorEncode(const upb_MessageDef* m, upb_Arena* a,
+ upb_StringView* out) {
+ upb_DescState s;
+ _upb_DescState_Init(&s);
+
+ const upb_FieldDef** sorted = NULL;
+ if (!m->is_sorted) {
+ sorted = _upb_FieldDefs_Sorted(m->fields, m->field_count, a);
+ if (!sorted) return false;
+ }
+
+ if (!_upb_DescState_Grow(&s, a)) return false;
+ s.ptr =
+ upb_MtDataEncoder_StartMessage(&s.e, s.ptr, _upb_MessageDef_Modifiers(m));
+
+ for (int i = 0; i < m->field_count; i++) {
+ const upb_FieldDef* f = sorted ? sorted[i] : upb_MessageDef_Field(m, i);
+ const upb_FieldType type = upb_FieldDef_Type(f);
+ const int number = upb_FieldDef_Number(f);
+ const uint64_t modifiers = _upb_FieldDef_Modifiers(f);
+
+ if (!_upb_DescState_Grow(&s, a)) return false;
+ s.ptr = upb_MtDataEncoder_PutField(&s.e, s.ptr, type, number, modifiers);
+ }
+
+ for (int i = 0; i < m->oneof_count; i++) {
+ if (!_upb_DescState_Grow(&s, a)) return false;
+ s.ptr = upb_MtDataEncoder_StartOneof(&s.e, s.ptr);
+
+ const upb_OneofDef* o = upb_MessageDef_Oneof(m, i);
+ const int field_count = upb_OneofDef_FieldCount(o);
+ for (int j = 0; j < field_count; j++) {
+ const int number = upb_FieldDef_Number(upb_OneofDef_Field(o, j));
+
+ if (!_upb_DescState_Grow(&s, a)) return false;
+ s.ptr = upb_MtDataEncoder_PutOneofField(&s.e, s.ptr, number);
+ }
+ }
+
+ if (!_upb_DescState_Grow(&s, a)) return false;
+ *s.ptr = '\0';
+
+ out->data = s.buf;
+ out->size = s.ptr - s.buf;
+ return true;
+}
+
+static void create_msgdef(upb_DefBuilder* ctx, const char* prefix,
+ const google_protobuf_DescriptorProto* msg_proto,
+ const upb_MessageDef* containing_type,
+ upb_MessageDef* m) {
+ const google_protobuf_OneofDescriptorProto* const* oneofs;
+ const google_protobuf_FieldDescriptorProto* const* fields;
+ const google_protobuf_DescriptorProto_ExtensionRange* const* ext_ranges;
+ size_t n_oneof, n_field, n_ext_range, n_enum, n_ext, n_msg;
+ upb_StringView name;
+
+ // Must happen before _upb_DefBuilder_Add()
+ m->file = _upb_DefBuilder_File(ctx);
+
+ m->containing_type = containing_type;
+ m->is_sorted = true;
+
+ name = google_protobuf_DescriptorProto_name(msg_proto);
+ _upb_DefBuilder_CheckIdentNotFull(ctx, name);
+
+ m->full_name = _upb_DefBuilder_MakeFullName(ctx, prefix, name);
+ _upb_DefBuilder_Add(ctx, m->full_name, _upb_DefType_Pack(m, UPB_DEFTYPE_MSG));
+
+ oneofs = google_protobuf_DescriptorProto_oneof_decl(msg_proto, &n_oneof);
+ fields = google_protobuf_DescriptorProto_field(msg_proto, &n_field);
+ ext_ranges = google_protobuf_DescriptorProto_extension_range(msg_proto, &n_ext_range);
+
+ bool ok = upb_inttable_init(&m->itof, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+
+ ok = upb_strtable_init(&m->ntof, n_oneof + n_field, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+
+ if (ctx->layout) {
+ /* create_fielddef() below depends on this being set. */
+ UPB_ASSERT(ctx->msg_count < ctx->layout->msg_count);
+ m->layout = ctx->layout->msgs[ctx->msg_count++];
+ UPB_ASSERT(n_field == m->layout->field_count);
+ } else {
+ /* Allocate now (to allow cross-linking), populate later. */
+ m->layout = _upb_DefBuilder_Alloc(
+ ctx, sizeof(*m->layout) + sizeof(_upb_FastTable_Entry));
+ }
+
+ UBP_DEF_SET_OPTIONS(m->opts, DescriptorProto, MessageOptions, msg_proto);
+
+ m->oneof_count = n_oneof;
+ m->oneofs = _upb_OneofDefs_New(ctx, n_oneof, oneofs, m);
+
+ m->field_count = n_field;
+ m->fields =
+ _upb_FieldDefs_New(ctx, n_field, fields, m->full_name, m, &m->is_sorted);
+
+ m->ext_range_count = n_ext_range;
+ m->ext_ranges = _upb_ExtensionRanges_New(ctx, n_ext_range, ext_ranges, m);
+
+ const size_t synthetic_count = _upb_OneofDefs_Finalize(ctx, m);
+ m->real_oneof_count = m->oneof_count - synthetic_count;
+
+ assign_msg_wellknowntype(m);
+ upb_inttable_compact(&m->itof, ctx->arena);
+
+ const google_protobuf_EnumDescriptorProto* const* enums =
+ google_protobuf_DescriptorProto_enum_type(msg_proto, &n_enum);
+ m->nested_enum_count = n_enum;
+ m->nested_enums = _upb_EnumDefs_New(ctx, n_enum, enums, m);
+
+ const google_protobuf_FieldDescriptorProto* const* exts =
+ google_protobuf_DescriptorProto_extension(msg_proto, &n_ext);
+ m->nested_ext_count = n_ext;
+ m->nested_exts = _upb_FieldDefs_New(ctx, n_ext, exts, m->full_name, m, NULL);
+
+ const google_protobuf_DescriptorProto* const* msgs =
+ google_protobuf_DescriptorProto_nested_type(msg_proto, &n_msg);
+ m->nested_msg_count = n_msg;
+ m->nested_msgs = _upb_MessageDefs_New(ctx, n_msg, msgs, m);
+}
+
+// Allocate and initialize an array of |n| message defs.
+upb_MessageDef* _upb_MessageDefs_New(
+ upb_DefBuilder* ctx, int n, const google_protobuf_DescriptorProto* const* protos,
+ const upb_MessageDef* containing_type) {
+ _upb_DefType_CheckPadding(sizeof(upb_MessageDef));
+
+ const char* name = containing_type ? containing_type->full_name
+ : _upb_FileDef_RawPackage(ctx->file);
+
+ upb_MessageDef* m = _upb_DefBuilder_Alloc(ctx, sizeof(upb_MessageDef) * n);
+ for (int i = 0; i < n; i++) {
+ create_msgdef(ctx, name, protos[i], containing_type, &m[i]);
+ }
+ return m;
+}
+
+
+
+// Must be last.
+
+struct upb_MethodDef {
+ const google_protobuf_MethodOptions* opts;
+ upb_ServiceDef* service;
+ const char* full_name;
+ const upb_MessageDef* input_type;
+ const upb_MessageDef* output_type;
+ int index;
+ bool client_streaming;
+ bool server_streaming;
+};
+
+upb_MethodDef* _upb_MethodDef_At(const upb_MethodDef* m, int i) {
+ return (upb_MethodDef*)&m[i];
+}
+
+const upb_ServiceDef* upb_MethodDef_Service(const upb_MethodDef* m) {
+ return m->service;
+}
+
+const google_protobuf_MethodOptions* upb_MethodDef_Options(const upb_MethodDef* m) {
+ return m->opts;
+}
+
+bool upb_MethodDef_HasOptions(const upb_MethodDef* m) {
+ return m->opts != (void*)kUpbDefOptDefault;
+}
+
+const char* upb_MethodDef_FullName(const upb_MethodDef* m) {
+ return m->full_name;
+}
+
+const char* upb_MethodDef_Name(const upb_MethodDef* m) {
+ return _upb_DefBuilder_FullToShort(m->full_name);
+}
+
+int upb_MethodDef_Index(const upb_MethodDef* m) { return m->index; }
+
+const upb_MessageDef* upb_MethodDef_InputType(const upb_MethodDef* m) {
+ return m->input_type;
+}
+
+const upb_MessageDef* upb_MethodDef_OutputType(const upb_MethodDef* m) {
+ return m->output_type;
+}
+
+bool upb_MethodDef_ClientStreaming(const upb_MethodDef* m) {
+ return m->client_streaming;
+}
+
+bool upb_MethodDef_ServerStreaming(const upb_MethodDef* m) {
+ return m->server_streaming;
+}
+
+static void create_method(upb_DefBuilder* ctx,
+ const google_protobuf_MethodDescriptorProto* method_proto,
+ upb_ServiceDef* s, upb_MethodDef* m) {
+ upb_StringView name = google_protobuf_MethodDescriptorProto_name(method_proto);
+
+ m->service = s;
+ m->full_name =
+ _upb_DefBuilder_MakeFullName(ctx, upb_ServiceDef_FullName(s), name);
+ m->client_streaming =
+ google_protobuf_MethodDescriptorProto_client_streaming(method_proto);
+ m->server_streaming =
+ google_protobuf_MethodDescriptorProto_server_streaming(method_proto);
+ m->input_type = _upb_DefBuilder_Resolve(
+ ctx, m->full_name, m->full_name,
+ google_protobuf_MethodDescriptorProto_input_type(method_proto), UPB_DEFTYPE_MSG);
+ m->output_type = _upb_DefBuilder_Resolve(
+ ctx, m->full_name, m->full_name,
+ google_protobuf_MethodDescriptorProto_output_type(method_proto), UPB_DEFTYPE_MSG);
+
+ UBP_DEF_SET_OPTIONS(m->opts, MethodDescriptorProto, MethodOptions,
+ method_proto);
+}
+
+// Allocate and initialize an array of |n| method defs belonging to |s|.
+upb_MethodDef* _upb_MethodDefs_New(
+ upb_DefBuilder* ctx, int n,
+ const google_protobuf_MethodDescriptorProto* const* protos, upb_ServiceDef* s) {
+ upb_MethodDef* m = _upb_DefBuilder_Alloc(ctx, sizeof(upb_MethodDef) * n);
+ for (int i = 0; i < n; i++) {
+ create_method(ctx, protos[i], s, &m[i]);
+ m[i].index = i;
+ }
+ return m;
+}
+
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+// Must be last.
+
+struct upb_OneofDef {
+ const google_protobuf_OneofOptions* opts;
+ const upb_MessageDef* parent;
+ const char* full_name;
+ int field_count;
+ bool synthetic;
+ const upb_FieldDef** fields;
+ upb_strtable ntof; // lookup a field by name
+ upb_inttable itof; // lookup a field by number (index)
+#if UINTPTR_MAX == 0xffffffff
+ uint32_t padding; // Increase size to a multiple of 8.
+#endif
+};
+
+upb_OneofDef* _upb_OneofDef_At(const upb_OneofDef* o, int i) {
+ return (upb_OneofDef*)&o[i];
+}
+
+const google_protobuf_OneofOptions* upb_OneofDef_Options(const upb_OneofDef* o) {
+ return o->opts;
+}
+
+bool upb_OneofDef_HasOptions(const upb_OneofDef* o) {
+ return o->opts != (void*)kUpbDefOptDefault;
+}
+
+const char* upb_OneofDef_FullName(const upb_OneofDef* o) {
+ return o->full_name;
+}
+
+const char* upb_OneofDef_Name(const upb_OneofDef* o) {
+ return _upb_DefBuilder_FullToShort(o->full_name);
+}
+
+const upb_MessageDef* upb_OneofDef_ContainingType(const upb_OneofDef* o) {
+ return o->parent;
+}
+
+int upb_OneofDef_FieldCount(const upb_OneofDef* o) { return o->field_count; }
+
+const upb_FieldDef* upb_OneofDef_Field(const upb_OneofDef* o, int i) {
+ UPB_ASSERT(i < o->field_count);
+ return o->fields[i];
+}
+
+int upb_OneofDef_numfields(const upb_OneofDef* o) { return o->field_count; }
+
+uint32_t upb_OneofDef_Index(const upb_OneofDef* o) {
+ // Compute index in our parent's array.
+ return o - upb_MessageDef_Oneof(o->parent, 0);
+}
+
+bool upb_OneofDef_IsSynthetic(const upb_OneofDef* o) { return o->synthetic; }
+
+const upb_FieldDef* upb_OneofDef_LookupNameWithSize(const upb_OneofDef* o,
+ const char* name,
+ size_t size) {
+ upb_value val;
+ return upb_strtable_lookup2(&o->ntof, name, size, &val)
+ ? upb_value_getptr(val)
+ : NULL;
+}
+
+const upb_FieldDef* upb_OneofDef_LookupName(const upb_OneofDef* o,
+ const char* name) {
+ return upb_OneofDef_LookupNameWithSize(o, name, strlen(name));
+}
+
+const upb_FieldDef* upb_OneofDef_LookupNumber(const upb_OneofDef* o,
+ uint32_t num) {
+ upb_value val;
+ return upb_inttable_lookup(&o->itof, num, &val) ? upb_value_getptr(val)
+ : NULL;
+}
+
+bool _upb_OneofDef_Insert(upb_OneofDef* o, const upb_FieldDef* f,
+ const char* name, size_t size, upb_Arena* a) {
+ o->field_count++;
+ if (_upb_FieldDef_IsProto3Optional(f)) o->synthetic = true;
+
+ const int number = upb_FieldDef_Number(f);
+ const upb_value v = upb_value_constptr(f);
+ return upb_inttable_insert(&o->itof, number, v, a) &&
+ upb_strtable_insert(&o->ntof, name, size, v, a);
+}
+
+// Returns the synthetic count.
+size_t _upb_OneofDefs_Finalize(upb_DefBuilder* ctx, upb_MessageDef* m) {
+ int synthetic_count = 0;
+
+ for (int i = 0; i < upb_MessageDef_OneofCount(m); i++) {
+ upb_OneofDef* o = (upb_OneofDef*)upb_MessageDef_Oneof(m, i);
+
+ if (o->synthetic && o->field_count != 1) {
+ _upb_DefBuilder_Errf(ctx,
+ "Synthetic oneofs must have one field, not %d: %s",
+ o->field_count, upb_OneofDef_Name(o));
+ }
+
+ if (o->synthetic) {
+ synthetic_count++;
+ } else if (synthetic_count != 0) {
+ _upb_DefBuilder_Errf(
+ ctx, "Synthetic oneofs must be after all other oneofs: %s",
+ upb_OneofDef_Name(o));
+ }
+
+ o->fields =
+ _upb_DefBuilder_Alloc(ctx, sizeof(upb_FieldDef*) * o->field_count);
+ o->field_count = 0;
+ }
+
+ for (int i = 0; i < upb_MessageDef_FieldCount(m); i++) {
+ const upb_FieldDef* f = upb_MessageDef_Field(m, i);
+ upb_OneofDef* o = (upb_OneofDef*)upb_FieldDef_ContainingOneof(f);
+ if (o) {
+ o->fields[o->field_count++] = f;
+ }
+ }
+
+ return synthetic_count;
+}
+
+static void create_oneofdef(upb_DefBuilder* ctx, upb_MessageDef* m,
+ const google_protobuf_OneofDescriptorProto* oneof_proto,
+ const upb_OneofDef* _o) {
+ upb_OneofDef* o = (upb_OneofDef*)_o;
+ upb_StringView name = google_protobuf_OneofDescriptorProto_name(oneof_proto);
+
+ o->parent = m;
+ o->full_name =
+ _upb_DefBuilder_MakeFullName(ctx, upb_MessageDef_FullName(m), name);
+ o->field_count = 0;
+ o->synthetic = false;
+
+ UBP_DEF_SET_OPTIONS(o->opts, OneofDescriptorProto, OneofOptions, oneof_proto);
+
+ if (upb_MessageDef_FindByNameWithSize(m, name.data, name.size, NULL, NULL)) {
+ _upb_DefBuilder_Errf(ctx, "duplicate oneof name (%s)", o->full_name);
+ }
+
+ upb_value v = _upb_DefType_Pack(o, UPB_DEFTYPE_ONEOF);
+ bool ok = _upb_MessageDef_Insert(m, name.data, name.size, v, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+
+ ok = upb_inttable_init(&o->itof, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+
+ ok = upb_strtable_init(&o->ntof, 4, ctx->arena);
+ if (!ok) _upb_DefBuilder_OomErr(ctx);
+}
+
+// Allocate and initialize an array of |n| oneof defs.
+upb_OneofDef* _upb_OneofDefs_New(
+ upb_DefBuilder* ctx, int n,
+ const google_protobuf_OneofDescriptorProto* const* protos, upb_MessageDef* m) {
+ _upb_DefType_CheckPadding(sizeof(upb_OneofDef));
+
+ upb_OneofDef* o = _upb_DefBuilder_Alloc(ctx, sizeof(upb_OneofDef) * n);
+ for (int i = 0; i < n; i++) {
+ create_oneofdef(ctx, m, protos[i], &o[i]);
+ }
+ return o;
+}
+
+
+
+// Must be last.
+
+struct upb_ServiceDef {
+ const google_protobuf_ServiceOptions* opts;
+ const upb_FileDef* file;
+ const char* full_name;
+ upb_MethodDef* methods;
+ int method_count;
+ int index;
+};
+
+upb_ServiceDef* _upb_ServiceDef_At(const upb_ServiceDef* s, int index) {
+ return (upb_ServiceDef*)&s[index];
+}
+
+const google_protobuf_ServiceOptions* upb_ServiceDef_Options(const upb_ServiceDef* s) {
+ return s->opts;
+}
+
+bool upb_ServiceDef_HasOptions(const upb_ServiceDef* s) {
+ return s->opts != (void*)kUpbDefOptDefault;
+}
+
+const char* upb_ServiceDef_FullName(const upb_ServiceDef* s) {
+ return s->full_name;
+}
+
+const char* upb_ServiceDef_Name(const upb_ServiceDef* s) {
+ return _upb_DefBuilder_FullToShort(s->full_name);
+}
+
+int upb_ServiceDef_Index(const upb_ServiceDef* s) { return s->index; }
+
+const upb_FileDef* upb_ServiceDef_File(const upb_ServiceDef* s) {
+ return s->file;
+}
+
+int upb_ServiceDef_MethodCount(const upb_ServiceDef* s) {
+ return s->method_count;
+}
+
+const upb_MethodDef* upb_ServiceDef_Method(const upb_ServiceDef* s, int i) {
+ return (i < 0 || i >= s->method_count) ? NULL
+ : _upb_MethodDef_At(s->methods, i);
+}
+
+const upb_MethodDef* upb_ServiceDef_FindMethodByName(const upb_ServiceDef* s,
+ const char* name) {
+ for (int i = 0; i < s->method_count; i++) {
+ const upb_MethodDef* m = _upb_MethodDef_At(s->methods, i);
+ if (strcmp(name, upb_MethodDef_Name(m)) == 0) {
+ return m;
+ }
+ }
+ return NULL;
+}
+
+static void create_service(upb_DefBuilder* ctx,
+ const google_protobuf_ServiceDescriptorProto* svc_proto,
+ upb_ServiceDef* s) {
+ upb_StringView name;
+ size_t n;
+
+ // Must happen before _upb_DefBuilder_Add()
+ s->file = _upb_DefBuilder_File(ctx);
+
+ name = google_protobuf_ServiceDescriptorProto_name(svc_proto);
+ _upb_DefBuilder_CheckIdentNotFull(ctx, name);
+ const char* package = _upb_FileDef_RawPackage(s->file);
+ s->full_name = _upb_DefBuilder_MakeFullName(ctx, package, name);
+ _upb_DefBuilder_Add(ctx, s->full_name,
+ _upb_DefType_Pack(s, UPB_DEFTYPE_SERVICE));
+
+ const google_protobuf_MethodDescriptorProto* const* methods =
+ google_protobuf_ServiceDescriptorProto_method(svc_proto, &n);
+ s->method_count = n;
+ s->methods = _upb_MethodDefs_New(ctx, n, methods, s);
+
+ UBP_DEF_SET_OPTIONS(s->opts, ServiceDescriptorProto, ServiceOptions,
+ svc_proto);
+}
+
+upb_ServiceDef* _upb_ServiceDefs_New(
+ upb_DefBuilder* ctx, int n,
+ const google_protobuf_ServiceDescriptorProto* const* protos) {
+ _upb_DefType_CheckPadding(sizeof(upb_ServiceDef));
+
+ upb_ServiceDef* s = _upb_DefBuilder_Alloc(ctx, sizeof(upb_ServiceDef) * n);
+ for (int i = 0; i < n; i++) {
+ create_service(ctx, protos[i], &s[i]);
+ s[i].index = i;
+ }
+ return s;
+}
+
/*
* upb_table Implementation
*
* Implementation is heavily inspired by Lua's ltable.c.
*/
+
#include <string.h>
-
-/* Must be last. */
+// Must be last.
#define UPB_MAXARRSIZE 16 /* 64k. */
@@ -3232,67 +10034,11 @@
i1->array_part == i2->array_part;
}
-/** upb/upb.c ************************************************************/
-#include <errno.h>
-#include <float.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include <stdlib.h>
// Must be last.
-/* upb_Status *****************************************************************/
-
-void upb_Status_Clear(upb_Status* status) {
- if (!status) return;
- status->ok = true;
- status->msg[0] = '\0';
-}
-
-bool upb_Status_IsOk(const upb_Status* status) { return status->ok; }
-
-const char* upb_Status_ErrorMessage(const upb_Status* status) {
- return status->msg;
-}
-
-void upb_Status_SetErrorMessage(upb_Status* status, const char* msg) {
- if (!status) return;
- status->ok = false;
- strncpy(status->msg, msg, _kUpb_Status_MaxMessage - 1);
- status->msg[_kUpb_Status_MaxMessage - 1] = '\0';
-}
-
-void upb_Status_SetErrorFormat(upb_Status* status, const char* fmt, ...) {
- va_list args;
- va_start(args, fmt);
- upb_Status_VSetErrorFormat(status, fmt, args);
- va_end(args);
-}
-
-void upb_Status_VSetErrorFormat(upb_Status* status, const char* fmt,
- va_list args) {
- if (!status) return;
- status->ok = false;
- vsnprintf(status->msg, sizeof(status->msg), fmt, args);
- status->msg[_kUpb_Status_MaxMessage - 1] = '\0';
-}
-
-void upb_Status_VAppendErrorFormat(upb_Status* status, const char* fmt,
- va_list args) {
- size_t len;
- if (!status) return;
- status->ok = false;
- len = strlen(status->msg);
- vsnprintf(status->msg + len, sizeof(status->msg) - len, fmt, args);
- status->msg[_kUpb_Status_MaxMessage - 1] = '\0';
-}
-
-/* upb_alloc ******************************************************************/
-
static void* upb_global_allocfunc(upb_alloc* alloc, void* ptr, size_t oldsize,
size_t size) {
UPB_UNUSED(alloc);
@@ -3305,6 +10051,11 @@
}
}
+upb_alloc upb_alloc_global = {&upb_global_allocfunc};
+
+
+// Must be last.
+
static uint32_t* upb_cleanup_pointer(uintptr_t cleanup_metadata) {
return (uint32_t*)(cleanup_metadata & ~0x1);
}
@@ -3318,12 +10069,6 @@
return (uintptr_t)cleanup | has_initial_block;
}
-upb_alloc upb_alloc_global = {&upb_global_allocfunc};
-
-/* upb_Arena ******************************************************************/
-
-/* Be conservative and choose 16 in case anyone is using SSE. */
-
struct mem_block {
struct mem_block* next;
uint32_t size;
@@ -3336,7 +10081,8 @@
void* ud;
} cleanup_ent;
-static const size_t memblock_reserve = UPB_ALIGN_UP(sizeof(mem_block), 16);
+static const size_t memblock_reserve =
+ UPB_ALIGN_UP(sizeof(mem_block), UPB_MALLOC_ALIGN);
static upb_Arena* arena_findroot(upb_Arena* a) {
/* Path splitting keeps time complexity down, see:
@@ -3349,6 +10095,24 @@
return a;
}
+size_t upb_Arena_SpaceAllocated(upb_Arena* arena) {
+ arena = arena_findroot(arena);
+ size_t memsize = 0;
+
+ mem_block* block = arena->freelist;
+
+ while (block) {
+ memsize += sizeof(mem_block) + block->size;
+ block = block->next;
+ }
+
+ return memsize;
+}
+
+uint32_t upb_Arena_DebugRefCount(upb_Arena* arena) {
+ return arena_findroot(arena)->refcount;
+}
+
static void upb_Arena_addblock(upb_Arena* a, upb_Arena* root, void* ptr,
size_t size) {
mem_block* block = ptr;
@@ -3393,7 +10157,7 @@
/* Public Arena API ***********************************************************/
-upb_Arena* arena_initslow(void* mem, size_t n, upb_alloc* alloc) {
+static upb_Arena* arena_initslow(void* mem, size_t n, upb_alloc* alloc) {
const size_t first_block_overhead = sizeof(upb_Arena) + memblock_reserve;
upb_Arena* a;
@@ -3424,7 +10188,7 @@
if (n) {
/* Align initial pointer up so that we return properly-aligned pointers. */
- void* aligned = (void*)UPB_ALIGN_UP((uintptr_t)mem, 16);
+ void* aligned = (void*)UPB_ALIGN_UP((uintptr_t)mem, UPB_MALLOC_ALIGN);
size_t delta = (uintptr_t)aligned - (uintptr_t)mem;
n = delta <= n ? n - delta : 0;
mem = aligned;
@@ -3448,6 +10212,7 @@
a->head.ptr = mem;
a->head.end = UPB_PTR_AT(mem, n - sizeof(*a), char);
a->freelist = NULL;
+ a->freelist_tail = NULL;
a->cleanup_metadata = upb_cleanup_metadata(NULL, true);
return a;
@@ -3534,6 +10299,2280 @@
return true;
}
+
+#include <string.h>
+
+// Must be last.
+
+static const char _upb_CTypeo_sizelg2[12] = {
+ 0,
+ 0, /* kUpb_CType_Bool */
+ 2, /* kUpb_CType_Float */
+ 2, /* kUpb_CType_Int32 */
+ 2, /* kUpb_CType_UInt32 */
+ 2, /* kUpb_CType_Enum */
+ UPB_SIZE(2, 3), /* kUpb_CType_Message */
+ 3, /* kUpb_CType_Double */
+ 3, /* kUpb_CType_Int64 */
+ 3, /* kUpb_CType_UInt64 */
+ UPB_SIZE(3, 4), /* kUpb_CType_String */
+ UPB_SIZE(3, 4), /* kUpb_CType_Bytes */
+};
+
+upb_Array* upb_Array_New(upb_Arena* a, upb_CType type) {
+ return _upb_Array_New(a, 4, _upb_CTypeo_sizelg2[type]);
+}
+
+size_t upb_Array_Size(const upb_Array* arr) { return arr->size; }
+
+upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i) {
+ upb_MessageValue ret;
+ const char* data = _upb_array_constptr(arr);
+ int lg2 = arr->data & 7;
+ UPB_ASSERT(i < arr->size);
+ memcpy(&ret, data + (i << lg2), 1 << lg2);
+ return ret;
+}
+
+void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val) {
+ char* data = _upb_array_ptr(arr);
+ int lg2 = arr->data & 7;
+ UPB_ASSERT(i < arr->size);
+ memcpy(data + (i << lg2), &val, 1 << lg2);
+}
+
+bool upb_Array_Append(upb_Array* arr, upb_MessageValue val, upb_Arena* arena) {
+ if (!upb_Array_Resize(arr, arr->size + 1, arena)) {
+ return false;
+ }
+ upb_Array_Set(arr, arr->size - 1, val);
+ return true;
+}
+
+void upb_Array_Move(upb_Array* arr, size_t dst_idx, size_t src_idx,
+ size_t count) {
+ char* data = _upb_array_ptr(arr);
+ int lg2 = arr->data & 7;
+ memmove(&data[dst_idx << lg2], &data[src_idx << lg2], count << lg2);
+}
+
+bool upb_Array_Insert(upb_Array* arr, size_t i, size_t count,
+ upb_Arena* arena) {
+ UPB_ASSERT(i <= arr->size);
+ UPB_ASSERT(count + arr->size >= count);
+ size_t oldsize = arr->size;
+ if (!upb_Array_Resize(arr, arr->size + count, arena)) {
+ return false;
+ }
+ upb_Array_Move(arr, i + count, i, oldsize - i);
+ return true;
+}
+
+/*
+ * i end arr->size
+ * |------------|XXXXXXXX|--------|
+ */
+void upb_Array_Delete(upb_Array* arr, size_t i, size_t count) {
+ size_t end = i + count;
+ UPB_ASSERT(i <= end);
+ UPB_ASSERT(end <= arr->size);
+ upb_Array_Move(arr, i, end, arr->size - end);
+ arr->size -= count;
+}
+
+bool upb_Array_Resize(upb_Array* arr, size_t size, upb_Arena* arena) {
+ return _upb_Array_Resize(arr, size, arena);
+}
+
+
+#include <string.h>
+
+
+// Must be last.
+
+// A few fake field types for our tables.
+enum {
+ kUpb_FakeFieldType_FieldNotFound = 0,
+ kUpb_FakeFieldType_MessageSetItem = 19,
+};
+
+// DecodeOp: an action to be performed for a wire-type/field-type combination.
+enum {
+ // Special ops: we don't write data to regular fields for these.
+ kUpb_DecodeOp_UnknownField = -1,
+ kUpb_DecodeOp_MessageSetItem = -2,
+
+ // Scalar-only ops.
+ kUpb_DecodeOp_Scalar1Byte = 0,
+ kUpb_DecodeOp_Scalar4Byte = 2,
+ kUpb_DecodeOp_Scalar8Byte = 3,
+ kUpb_DecodeOp_Enum = 1,
+
+ // Scalar/repeated ops.
+ kUpb_DecodeOp_String = 4,
+ kUpb_DecodeOp_Bytes = 5,
+ kUpb_DecodeOp_SubMessage = 6,
+
+ // Repeated-only ops (also see macros below).
+ kUpb_DecodeOp_PackedEnum = 13,
+};
+
+// For packed fields it is helpful to be able to recover the lg2 of the data
+// size from the op.
+#define OP_FIXPCK_LG2(n) (n + 5) /* n in [2, 3] => op in [7, 8] */
+#define OP_VARPCK_LG2(n) (n + 9) /* n in [0, 2, 3] => op in [9, 11, 12] */
+
+typedef union {
+ bool bool_val;
+ uint32_t uint32_val;
+ uint64_t uint64_val;
+ uint32_t size;
+} wireval;
+
+static const char* _upb_Decoder_DecodeMessage(upb_Decoder* d, const char* ptr,
+ upb_Message* msg,
+ const upb_MiniTable* layout);
+
+UPB_NORETURN static void* _upb_Decoder_ErrorJmp(upb_Decoder* d,
+ upb_DecodeStatus status) {
+ assert(status != kUpb_DecodeStatus_Ok);
+ UPB_LONGJMP(d->err, status);
+}
+
+const char* _upb_FastDecoder_ErrorJmp(upb_Decoder* d, int status) {
+ assert(status != kUpb_DecodeStatus_Ok);
+ UPB_LONGJMP(d->err, status);
+ return NULL;
+}
+static void _upb_Decoder_VerifyUtf8(upb_Decoder* d, const char* buf, int len) {
+ if (!_upb_Decoder_VerifyUtf8Inline(buf, len)) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_BadUtf8);
+ }
+}
+
+static bool _upb_Decoder_Reserve(upb_Decoder* d, upb_Array* arr, size_t elem) {
+ bool need_realloc = arr->capacity - arr->size < elem;
+ if (need_realloc && !_upb_array_realloc(arr, arr->size + elem, &d->arena)) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ }
+ return need_realloc;
+}
+
+typedef struct {
+ const char* ptr;
+ uint64_t val;
+} _upb_DecodeLongVarintReturn;
+
+UPB_NOINLINE
+static _upb_DecodeLongVarintReturn _upb_Decoder_DecodeLongVarint(
+ const char* ptr, uint64_t val) {
+ _upb_DecodeLongVarintReturn ret = {NULL, 0};
+ uint64_t byte;
+ int i;
+ for (i = 1; i < 10; i++) {
+ byte = (uint8_t)ptr[i];
+ val += (byte - 1) << (i * 7);
+ if (!(byte & 0x80)) {
+ ret.ptr = ptr + i + 1;
+ ret.val = val;
+ return ret;
+ }
+ }
+ return ret;
+}
+
+UPB_FORCEINLINE
+static const char* _upb_Decoder_DecodeVarint(upb_Decoder* d, const char* ptr,
+ uint64_t* val) {
+ uint64_t byte = (uint8_t)*ptr;
+ if (UPB_LIKELY((byte & 0x80) == 0)) {
+ *val = byte;
+ return ptr + 1;
+ } else {
+ _upb_DecodeLongVarintReturn res = _upb_Decoder_DecodeLongVarint(ptr, byte);
+ if (!res.ptr) _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
+ *val = res.val;
+ return res.ptr;
+ }
+}
+
+UPB_FORCEINLINE
+static const char* _upb_Decoder_DecodeTag(upb_Decoder* d, const char* ptr,
+ uint32_t* val) {
+ uint64_t byte = (uint8_t)*ptr;
+ if (UPB_LIKELY((byte & 0x80) == 0)) {
+ *val = byte;
+ return ptr + 1;
+ } else {
+ const char* start = ptr;
+ _upb_DecodeLongVarintReturn res = _upb_Decoder_DecodeLongVarint(ptr, byte);
+ if (!res.ptr || res.ptr - start > 5 || res.val > UINT32_MAX) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
+ }
+ *val = res.val;
+ return res.ptr;
+ }
+}
+
+UPB_FORCEINLINE
+static const char* upb_Decoder_DecodeSize(upb_Decoder* d, const char* ptr,
+ uint32_t* size) {
+ uint64_t size64;
+ ptr = _upb_Decoder_DecodeVarint(d, ptr, &size64);
+ if (size64 >= INT32_MAX || ptr - d->end + (int)size64 > d->limit) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
+ }
+ *size = size64;
+ return ptr;
+}
+
+static void _upb_Decoder_MungeInt32(wireval* val) {
+ if (!_upb_IsLittleEndian()) {
+ /* The next stage will memcpy(dst, &val, 4) */
+ val->uint32_val = val->uint64_val;
+ }
+}
+
+static void _upb_Decoder_Munge(int type, wireval* val) {
+ switch (type) {
+ case kUpb_FieldType_Bool:
+ val->bool_val = val->uint64_val != 0;
+ break;
+ case kUpb_FieldType_SInt32: {
+ uint32_t n = val->uint64_val;
+ val->uint32_val = (n >> 1) ^ -(int32_t)(n & 1);
+ break;
+ }
+ case kUpb_FieldType_SInt64: {
+ uint64_t n = val->uint64_val;
+ val->uint64_val = (n >> 1) ^ -(int64_t)(n & 1);
+ break;
+ }
+ case kUpb_FieldType_Int32:
+ case kUpb_FieldType_UInt32:
+ case kUpb_FieldType_Enum:
+ _upb_Decoder_MungeInt32(val);
+ break;
+ }
+}
+
+static upb_Message* _upb_Decoder_NewSubMessage(
+ upb_Decoder* d, const upb_MiniTable_Sub* subs,
+ const upb_MiniTable_Field* field) {
+ const upb_MiniTable* subl = subs[field->submsg_index].submsg;
+ upb_Message* msg = _upb_Message_New_inl(subl, &d->arena);
+ if (!msg) _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ return msg;
+}
+
+UPB_NOINLINE
+const char* _upb_Decoder_IsDoneFallback(upb_Decoder* d, const char* ptr,
+ int overrun) {
+ int status;
+ ptr = _upb_Decoder_IsDoneFallbackInline(d, ptr, overrun, &status);
+ if (ptr == NULL) _upb_Decoder_ErrorJmp(d, status);
+ return ptr;
+}
+
+static const char* _upb_Decoder_ReadString(upb_Decoder* d, const char* ptr,
+ int size, upb_StringView* str) {
+ if (d->options & kUpb_DecodeOption_AliasString) {
+ str->data = ptr;
+ } else {
+ char* data = upb_Arena_Malloc(&d->arena, size);
+ if (!data) _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ memcpy(data, ptr, size);
+ str->data = data;
+ }
+ str->size = size;
+ return ptr + size;
+}
+
+UPB_FORCEINLINE
+static const char* _upb_Decoder_RecurseSubMessage(upb_Decoder* d,
+ const char* ptr,
+ upb_Message* submsg,
+ const upb_MiniTable* subl,
+ uint32_t expected_end_group) {
+ if (--d->depth < 0) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_MaxDepthExceeded);
+ }
+ ptr = _upb_Decoder_DecodeMessage(d, ptr, submsg, subl);
+ d->depth++;
+ if (d->end_group != expected_end_group) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
+ }
+ return ptr;
+}
+
+UPB_FORCEINLINE
+static const char* _upb_Decoder_DecodeSubMessage(
+ upb_Decoder* d, const char* ptr, upb_Message* submsg,
+ const upb_MiniTable_Sub* subs, const upb_MiniTable_Field* field, int size) {
+ int saved_delta = _upb_Decoder_PushLimit(d, ptr, size);
+ const upb_MiniTable* subl = subs[field->submsg_index].submsg;
+ ptr = _upb_Decoder_RecurseSubMessage(d, ptr, submsg, subl, DECODE_NOGROUP);
+ _upb_Decoder_PopLimit(d, ptr, saved_delta);
+ return ptr;
+}
+
+UPB_FORCEINLINE
+static const char* _upb_Decoder_DecodeGroup(upb_Decoder* d, const char* ptr,
+ upb_Message* submsg,
+ const upb_MiniTable* subl,
+ uint32_t number) {
+ if (_upb_Decoder_IsDone(d, &ptr)) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
+ }
+ ptr = _upb_Decoder_RecurseSubMessage(d, ptr, submsg, subl, number);
+ d->end_group = DECODE_NOGROUP;
+ return ptr;
+}
+
+UPB_FORCEINLINE
+static const char* _upb_Decoder_DecodeUnknownGroup(upb_Decoder* d,
+ const char* ptr,
+ uint32_t number) {
+ return _upb_Decoder_DecodeGroup(d, ptr, NULL, NULL, number);
+}
+
+UPB_FORCEINLINE
+static const char* _upb_Decoder_DecodeKnownGroup(
+ upb_Decoder* d, const char* ptr, upb_Message* submsg,
+ const upb_MiniTable_Sub* subs, const upb_MiniTable_Field* field) {
+ const upb_MiniTable* subl = subs[field->submsg_index].submsg;
+ return _upb_Decoder_DecodeGroup(d, ptr, submsg, subl, field->number);
+}
+
+static char* upb_Decoder_EncodeVarint32(uint32_t val, char* ptr) {
+ do {
+ uint8_t byte = val & 0x7fU;
+ val >>= 7;
+ if (val) byte |= 0x80U;
+ *(ptr++) = byte;
+ } while (val);
+ return ptr;
+}
+
+static void _upb_Decoder_AddUnknownVarints(upb_Decoder* d, upb_Message* msg,
+ uint32_t val1, uint32_t val2) {
+ char buf[20];
+ char* end = buf;
+ end = upb_Decoder_EncodeVarint32(val1, end);
+ end = upb_Decoder_EncodeVarint32(val2, end);
+
+ if (!_upb_Message_AddUnknown(msg, buf, end - buf, &d->arena)) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ }
+}
+
+UPB_NOINLINE
+static bool _upb_Decoder_CheckEnumSlow(upb_Decoder* d, const char* ptr,
+ upb_Message* msg,
+ const upb_MiniTable_Enum* e,
+ const upb_MiniTable_Field* field,
+ uint32_t v) {
+ if (_upb_MiniTable_CheckEnumValueSlow(e, v)) return true;
+
+ // Unrecognized enum goes into unknown fields.
+ // For packed fields the tag could be arbitrarily far in the past, so we
+ // just re-encode the tag and value here.
+ uint32_t tag = ((uint32_t)field->number << 3) | kUpb_WireType_Varint;
+ upb_Message* unknown_msg =
+ field->mode & kUpb_LabelFlags_IsExtension ? d->unknown_msg : msg;
+ _upb_Decoder_AddUnknownVarints(d, unknown_msg, tag, v);
+ return false;
+}
+
+UPB_FORCEINLINE
+static bool _upb_Decoder_CheckEnum(upb_Decoder* d, const char* ptr,
+ upb_Message* msg,
+ const upb_MiniTable_Enum* e,
+ const upb_MiniTable_Field* field,
+ wireval* val) {
+ uint32_t v = val->uint32_val;
+
+ _kUpb_FastEnumCheck_Status status = _upb_MiniTable_CheckEnumValueFast(e, v);
+ if (UPB_LIKELY(status == _kUpb_FastEnumCheck_ValueIsInEnum)) return true;
+ return _upb_Decoder_CheckEnumSlow(d, ptr, msg, e, field, v);
+}
+
+UPB_NOINLINE
+static const char* _upb_Decoder_DecodeEnumArray(
+ upb_Decoder* d, const char* ptr, upb_Message* msg, upb_Array* arr,
+ const upb_MiniTable_Sub* subs, const upb_MiniTable_Field* field,
+ wireval* val) {
+ const upb_MiniTable_Enum* e = subs[field->submsg_index].subenum;
+ if (!_upb_Decoder_CheckEnum(d, ptr, msg, e, field, val)) return ptr;
+ void* mem = UPB_PTR_AT(_upb_array_ptr(arr), arr->size * 4, void);
+ arr->size++;
+ memcpy(mem, val, 4);
+ return ptr;
+}
+
+UPB_FORCEINLINE
+static const char* _upb_Decoder_DecodeFixedPacked(
+ upb_Decoder* d, const char* ptr, upb_Array* arr, wireval* val,
+ const upb_MiniTable_Field* field, int lg2) {
+ int mask = (1 << lg2) - 1;
+ size_t count = val->size >> lg2;
+ if ((val->size & mask) != 0) {
+ // Length isn't a round multiple of elem size.
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
+ }
+ _upb_Decoder_Reserve(d, arr, count);
+ void* mem = UPB_PTR_AT(_upb_array_ptr(arr), arr->size << lg2, void);
+ arr->size += count;
+ // Note: if/when the decoder supports multi-buffer input, we will need to
+ // handle buffer seams here.
+ if (_upb_IsLittleEndian()) {
+ memcpy(mem, ptr, val->size);
+ ptr += val->size;
+ } else {
+ const char* end = ptr + val->size;
+ char* dst = mem;
+ while (ptr < end) {
+ if (lg2 == 2) {
+ uint32_t val;
+ memcpy(&val, ptr, sizeof(val));
+ val = _upb_BigEndian_Swap32(val);
+ memcpy(dst, &val, sizeof(val));
+ } else {
+ UPB_ASSERT(lg2 == 3);
+ uint64_t val;
+ memcpy(&val, ptr, sizeof(val));
+ val = _upb_BigEndian_Swap64(val);
+ memcpy(dst, &val, sizeof(val));
+ }
+ ptr += 1 << lg2;
+ dst += 1 << lg2;
+ }
+ }
+
+ return ptr;
+}
+
+UPB_FORCEINLINE
+static const char* _upb_Decoder_DecodeVarintPacked(
+ upb_Decoder* d, const char* ptr, upb_Array* arr, wireval* val,
+ const upb_MiniTable_Field* field, int lg2) {
+ int scale = 1 << lg2;
+ int saved_limit = _upb_Decoder_PushLimit(d, ptr, val->size);
+ char* out = UPB_PTR_AT(_upb_array_ptr(arr), arr->size << lg2, void);
+ while (!_upb_Decoder_IsDone(d, &ptr)) {
+ wireval elem;
+ ptr = _upb_Decoder_DecodeVarint(d, ptr, &elem.uint64_val);
+ _upb_Decoder_Munge(field->descriptortype, &elem);
+ if (_upb_Decoder_Reserve(d, arr, 1)) {
+ out = UPB_PTR_AT(_upb_array_ptr(arr), arr->size << lg2, void);
+ }
+ arr->size++;
+ memcpy(out, &elem, scale);
+ out += scale;
+ }
+ _upb_Decoder_PopLimit(d, ptr, saved_limit);
+ return ptr;
+}
+
+UPB_NOINLINE
+static const char* _upb_Decoder_DecodeEnumPacked(
+ upb_Decoder* d, const char* ptr, upb_Message* msg, upb_Array* arr,
+ const upb_MiniTable_Sub* subs, const upb_MiniTable_Field* field,
+ wireval* val) {
+ const upb_MiniTable_Enum* e = subs[field->submsg_index].subenum;
+ int saved_limit = _upb_Decoder_PushLimit(d, ptr, val->size);
+ char* out = UPB_PTR_AT(_upb_array_ptr(arr), arr->size * 4, void);
+ while (!_upb_Decoder_IsDone(d, &ptr)) {
+ wireval elem;
+ ptr = _upb_Decoder_DecodeVarint(d, ptr, &elem.uint64_val);
+ _upb_Decoder_MungeInt32(&elem);
+ if (!_upb_Decoder_CheckEnum(d, ptr, msg, e, field, &elem)) {
+ continue;
+ }
+ if (_upb_Decoder_Reserve(d, arr, 1)) {
+ out = UPB_PTR_AT(_upb_array_ptr(arr), arr->size * 4, void);
+ }
+ arr->size++;
+ memcpy(out, &elem, 4);
+ out += 4;
+ }
+ _upb_Decoder_PopLimit(d, ptr, saved_limit);
+ return ptr;
+}
+
+upb_Array* _upb_Decoder_CreateArray(upb_Decoder* d,
+ const upb_MiniTable_Field* field) {
+ /* Maps descriptor type -> elem_size_lg2. */
+ static const uint8_t kElemSizeLg2[] = {
+ [0] = -1, // invalid descriptor type
+ [kUpb_FieldType_Double] = 3,
+ [kUpb_FieldType_Float] = 2,
+ [kUpb_FieldType_Int64] = 3,
+ [kUpb_FieldType_UInt64] = 3,
+ [kUpb_FieldType_Int32] = 2,
+ [kUpb_FieldType_Fixed64] = 3,
+ [kUpb_FieldType_Fixed32] = 2,
+ [kUpb_FieldType_Bool] = 0,
+ [kUpb_FieldType_String] = UPB_SIZE(3, 4),
+ [kUpb_FieldType_Group] = UPB_SIZE(2, 3),
+ [kUpb_FieldType_Message] = UPB_SIZE(2, 3),
+ [kUpb_FieldType_Bytes] = UPB_SIZE(3, 4),
+ [kUpb_FieldType_UInt32] = 2,
+ [kUpb_FieldType_Enum] = 2,
+ [kUpb_FieldType_SFixed32] = 2,
+ [kUpb_FieldType_SFixed64] = 3,
+ [kUpb_FieldType_SInt32] = 2,
+ [kUpb_FieldType_SInt64] = 3,
+ };
+
+ size_t lg2 = kElemSizeLg2[field->descriptortype];
+ upb_Array* ret = _upb_Array_New(&d->arena, 4, lg2);
+ if (!ret) _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ return ret;
+}
+
+static const char* _upb_Decoder_DecodeToArray(upb_Decoder* d, const char* ptr,
+ upb_Message* msg,
+ const upb_MiniTable_Sub* subs,
+ const upb_MiniTable_Field* field,
+ wireval* val, int op) {
+ upb_Array** arrp = UPB_PTR_AT(msg, field->offset, void);
+ upb_Array* arr = *arrp;
+ void* mem;
+
+ if (arr) {
+ _upb_Decoder_Reserve(d, arr, 1);
+ } else {
+ arr = _upb_Decoder_CreateArray(d, field);
+ *arrp = arr;
+ }
+
+ switch (op) {
+ case kUpb_DecodeOp_Scalar1Byte:
+ case kUpb_DecodeOp_Scalar4Byte:
+ case kUpb_DecodeOp_Scalar8Byte:
+ /* Append scalar value. */
+ mem = UPB_PTR_AT(_upb_array_ptr(arr), arr->size << op, void);
+ arr->size++;
+ memcpy(mem, val, 1 << op);
+ return ptr;
+ case kUpb_DecodeOp_String:
+ _upb_Decoder_VerifyUtf8(d, ptr, val->size);
+ /* Fallthrough. */
+ case kUpb_DecodeOp_Bytes: {
+ /* Append bytes. */
+ upb_StringView* str = (upb_StringView*)_upb_array_ptr(arr) + arr->size;
+ arr->size++;
+ return _upb_Decoder_ReadString(d, ptr, val->size, str);
+ }
+ case kUpb_DecodeOp_SubMessage: {
+ /* Append submessage / group. */
+ upb_Message* submsg = _upb_Decoder_NewSubMessage(d, subs, field);
+ *UPB_PTR_AT(_upb_array_ptr(arr), arr->size * sizeof(void*),
+ upb_Message*) = submsg;
+ arr->size++;
+ if (UPB_UNLIKELY(field->descriptortype == kUpb_FieldType_Group)) {
+ return _upb_Decoder_DecodeKnownGroup(d, ptr, submsg, subs, field);
+ } else {
+ return _upb_Decoder_DecodeSubMessage(d, ptr, submsg, subs, field,
+ val->size);
+ }
+ }
+ case OP_FIXPCK_LG2(2):
+ case OP_FIXPCK_LG2(3):
+ return _upb_Decoder_DecodeFixedPacked(d, ptr, arr, val, field,
+ op - OP_FIXPCK_LG2(0));
+ case OP_VARPCK_LG2(0):
+ case OP_VARPCK_LG2(2):
+ case OP_VARPCK_LG2(3):
+ return _upb_Decoder_DecodeVarintPacked(d, ptr, arr, val, field,
+ op - OP_VARPCK_LG2(0));
+ case kUpb_DecodeOp_Enum:
+ return _upb_Decoder_DecodeEnumArray(d, ptr, msg, arr, subs, field, val);
+ case kUpb_DecodeOp_PackedEnum:
+ return _upb_Decoder_DecodeEnumPacked(d, ptr, msg, arr, subs, field, val);
+ default:
+ UPB_UNREACHABLE();
+ }
+}
+
+upb_Map* _upb_Decoder_CreateMap(upb_Decoder* d, const upb_MiniTable* entry) {
+ /* Maps descriptor type -> upb map size. */
+ static const uint8_t kSizeInMap[] = {
+ [0] = -1, // invalid descriptor type */
+ [kUpb_FieldType_Double] = 8,
+ [kUpb_FieldType_Float] = 4,
+ [kUpb_FieldType_Int64] = 8,
+ [kUpb_FieldType_UInt64] = 8,
+ [kUpb_FieldType_Int32] = 4,
+ [kUpb_FieldType_Fixed64] = 8,
+ [kUpb_FieldType_Fixed32] = 4,
+ [kUpb_FieldType_Bool] = 1,
+ [kUpb_FieldType_String] = UPB_MAPTYPE_STRING,
+ [kUpb_FieldType_Group] = sizeof(void*),
+ [kUpb_FieldType_Message] = sizeof(void*),
+ [kUpb_FieldType_Bytes] = UPB_MAPTYPE_STRING,
+ [kUpb_FieldType_UInt32] = 4,
+ [kUpb_FieldType_Enum] = 4,
+ [kUpb_FieldType_SFixed32] = 4,
+ [kUpb_FieldType_SFixed64] = 8,
+ [kUpb_FieldType_SInt32] = 4,
+ [kUpb_FieldType_SInt64] = 8,
+ };
+
+ const upb_MiniTable_Field* key_field = &entry->fields[0];
+ const upb_MiniTable_Field* val_field = &entry->fields[1];
+ char key_size = kSizeInMap[key_field->descriptortype];
+ char val_size = kSizeInMap[val_field->descriptortype];
+ UPB_ASSERT(key_field->offset == 0);
+ UPB_ASSERT(val_field->offset == sizeof(upb_StringView));
+ upb_Map* ret = _upb_Map_New(&d->arena, key_size, val_size);
+ if (!ret) _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ return ret;
+}
+
+static const char* _upb_Decoder_DecodeToMap(upb_Decoder* d, const char* ptr,
+ upb_Message* msg,
+ const upb_MiniTable_Sub* subs,
+ const upb_MiniTable_Field* field,
+ wireval* val) {
+ upb_Map** map_p = UPB_PTR_AT(msg, field->offset, upb_Map*);
+ upb_Map* map = *map_p;
+ upb_MapEntry ent;
+ const upb_MiniTable* entry = subs[field->submsg_index].submsg;
+
+ if (!map) {
+ map = _upb_Decoder_CreateMap(d, entry);
+ *map_p = map;
+ }
+
+ /* Parse map entry. */
+ memset(&ent, 0, sizeof(ent));
+
+ if (entry->fields[1].descriptortype == kUpb_FieldType_Message ||
+ entry->fields[1].descriptortype == kUpb_FieldType_Group) {
+ /* Create proactively to handle the case where it doesn't appear. */
+ ent.v.val =
+ upb_value_ptr(_upb_Message_New(entry->subs[0].submsg, &d->arena));
+ }
+
+ const char* start = ptr;
+ ptr = _upb_Decoder_DecodeSubMessage(d, ptr, &ent.k, subs, field, val->size);
+ // check if ent had any unknown fields
+ size_t size;
+ upb_Message_GetUnknown(&ent.k, &size);
+ if (size != 0) {
+ uint32_t tag = ((uint32_t)field->number << 3) | kUpb_WireType_Delimited;
+ _upb_Decoder_AddUnknownVarints(d, msg, tag, (uint32_t)(ptr - start));
+ if (!_upb_Message_AddUnknown(msg, start, ptr - start, &d->arena)) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ }
+ } else {
+ if (_upb_Map_Insert(map, &ent.k, map->key_size, &ent.v, map->val_size,
+ &d->arena) == _kUpb_MapInsertStatus_OutOfMemory) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ }
+ }
+ return ptr;
+}
+
+static const char* _upb_Decoder_DecodeToSubMessage(
+ upb_Decoder* d, const char* ptr, upb_Message* msg,
+ const upb_MiniTable_Sub* subs, const upb_MiniTable_Field* field,
+ wireval* val, int op) {
+ void* mem = UPB_PTR_AT(msg, field->offset, void);
+ int type = field->descriptortype;
+
+ if (UPB_UNLIKELY(op == kUpb_DecodeOp_Enum) &&
+ !_upb_Decoder_CheckEnum(d, ptr, msg, subs[field->submsg_index].subenum,
+ field, val)) {
+ return ptr;
+ }
+
+ /* Set presence if necessary. */
+ if (field->presence > 0) {
+ _upb_sethas_field(msg, field);
+ } else if (field->presence < 0) {
+ /* Oneof case */
+ uint32_t* oneof_case = _upb_oneofcase_field(msg, field);
+ if (op == kUpb_DecodeOp_SubMessage && *oneof_case != field->number) {
+ memset(mem, 0, sizeof(void*));
+ }
+ *oneof_case = field->number;
+ }
+
+ /* Store into message. */
+ switch (op) {
+ case kUpb_DecodeOp_SubMessage: {
+ upb_Message** submsgp = mem;
+ upb_Message* submsg = *submsgp;
+ if (!submsg) {
+ submsg = _upb_Decoder_NewSubMessage(d, subs, field);
+ *submsgp = submsg;
+ }
+ if (UPB_UNLIKELY(type == kUpb_FieldType_Group)) {
+ ptr = _upb_Decoder_DecodeKnownGroup(d, ptr, submsg, subs, field);
+ } else {
+ ptr = _upb_Decoder_DecodeSubMessage(d, ptr, submsg, subs, field,
+ val->size);
+ }
+ break;
+ }
+ case kUpb_DecodeOp_String:
+ _upb_Decoder_VerifyUtf8(d, ptr, val->size);
+ /* Fallthrough. */
+ case kUpb_DecodeOp_Bytes:
+ return _upb_Decoder_ReadString(d, ptr, val->size, mem);
+ case kUpb_DecodeOp_Scalar8Byte:
+ memcpy(mem, val, 8);
+ break;
+ case kUpb_DecodeOp_Enum:
+ case kUpb_DecodeOp_Scalar4Byte:
+ memcpy(mem, val, 4);
+ break;
+ case kUpb_DecodeOp_Scalar1Byte:
+ memcpy(mem, val, 1);
+ break;
+ default:
+ UPB_UNREACHABLE();
+ }
+
+ return ptr;
+}
+
+UPB_NOINLINE
+const char* _upb_Decoder_CheckRequired(upb_Decoder* d, const char* ptr,
+ const upb_Message* msg,
+ const upb_MiniTable* l) {
+ assert(l->required_count);
+ if (UPB_LIKELY((d->options & kUpb_DecodeOption_CheckRequired) == 0)) {
+ return ptr;
+ }
+ uint64_t msg_head;
+ memcpy(&msg_head, msg, 8);
+ msg_head = _upb_BigEndian_Swap64(msg_head);
+ if (upb_MiniTable_requiredmask(l) & ~msg_head) {
+ d->missing_required = true;
+ }
+ return ptr;
+}
+
+UPB_FORCEINLINE
+static bool _upb_Decoder_TryFastDispatch(upb_Decoder* d, const char** ptr,
+ upb_Message* msg,
+ const upb_MiniTable* layout) {
+#if UPB_FASTTABLE
+ if (layout && layout->table_mask != (unsigned char)-1) {
+ uint16_t tag = _upb_FastDecoder_LoadTag(*ptr);
+ intptr_t table = decode_totable(layout);
+ *ptr = _upb_FastDecoder_TagDispatch(d, *ptr, msg, table, 0, tag);
+ return true;
+ }
+#endif
+ return false;
+}
+
+static const char* upb_Decoder_SkipField(upb_Decoder* d, const char* ptr,
+ uint32_t tag) {
+ int field_number = tag >> 3;
+ int wire_type = tag & 7;
+ switch (wire_type) {
+ case kUpb_WireType_Varint: {
+ uint64_t val;
+ return _upb_Decoder_DecodeVarint(d, ptr, &val);
+ }
+ case kUpb_WireType_64Bit:
+ return ptr + 8;
+ case kUpb_WireType_32Bit:
+ return ptr + 4;
+ case kUpb_WireType_Delimited: {
+ uint32_t size;
+ ptr = upb_Decoder_DecodeSize(d, ptr, &size);
+ return ptr + size;
+ }
+ case kUpb_WireType_StartGroup:
+ return _upb_Decoder_DecodeUnknownGroup(d, ptr, field_number);
+ default:
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
+ }
+}
+
+enum {
+ kStartItemTag = ((1 << 3) | kUpb_WireType_StartGroup),
+ kEndItemTag = ((1 << 3) | kUpb_WireType_EndGroup),
+ kTypeIdTag = ((2 << 3) | kUpb_WireType_Varint),
+ kMessageTag = ((3 << 3) | kUpb_WireType_Delimited),
+};
+
+static void upb_Decoder_AddKnownMessageSetItem(
+ upb_Decoder* d, upb_Message* msg, const upb_MiniTable_Extension* item_mt,
+ const char* data, uint32_t size) {
+ upb_Message_Extension* ext =
+ _upb_Message_GetOrCreateExtension(msg, item_mt, &d->arena);
+ if (UPB_UNLIKELY(!ext)) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ }
+ upb_Message* submsg =
+ _upb_Decoder_NewSubMessage(d, &ext->ext->sub, &ext->ext->field);
+ upb_DecodeStatus status = upb_Decode(data, size, submsg, item_mt->sub.submsg,
+ d->extreg, d->options, &d->arena);
+ memcpy(&ext->data, &submsg, sizeof(submsg));
+ if (status != kUpb_DecodeStatus_Ok) _upb_Decoder_ErrorJmp(d, status);
+}
+
+static void upb_Decoder_AddUnknownMessageSetItem(upb_Decoder* d,
+ upb_Message* msg,
+ uint32_t type_id,
+ const char* message_data,
+ uint32_t message_size) {
+ char buf[60];
+ char* ptr = buf;
+ ptr = upb_Decoder_EncodeVarint32(kStartItemTag, ptr);
+ ptr = upb_Decoder_EncodeVarint32(kTypeIdTag, ptr);
+ ptr = upb_Decoder_EncodeVarint32(type_id, ptr);
+ ptr = upb_Decoder_EncodeVarint32(kMessageTag, ptr);
+ ptr = upb_Decoder_EncodeVarint32(message_size, ptr);
+ char* split = ptr;
+
+ ptr = upb_Decoder_EncodeVarint32(kEndItemTag, ptr);
+ char* end = ptr;
+
+ if (!_upb_Message_AddUnknown(msg, buf, split - buf, &d->arena) ||
+ !_upb_Message_AddUnknown(msg, message_data, message_size, &d->arena) ||
+ !_upb_Message_AddUnknown(msg, split, end - split, &d->arena)) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ }
+}
+
+static void upb_Decoder_AddMessageSetItem(upb_Decoder* d, upb_Message* msg,
+ const upb_MiniTable* layout,
+ uint32_t type_id, const char* data,
+ uint32_t size) {
+ const upb_MiniTable_Extension* item_mt =
+ _upb_extreg_get(d->extreg, layout, type_id);
+ if (item_mt) {
+ upb_Decoder_AddKnownMessageSetItem(d, msg, item_mt, data, size);
+ } else {
+ upb_Decoder_AddUnknownMessageSetItem(d, msg, type_id, data, size);
+ }
+}
+
+static const char* upb_Decoder_DecodeMessageSetItem(
+ upb_Decoder* d, const char* ptr, upb_Message* msg,
+ const upb_MiniTable* layout) {
+ uint32_t type_id = 0;
+ upb_StringView preserved = {NULL, 0};
+ typedef enum {
+ kUpb_HaveId = 1 << 0,
+ kUpb_HavePayload = 1 << 1,
+ } StateMask;
+ StateMask state_mask = 0;
+ while (!_upb_Decoder_IsDone(d, &ptr)) {
+ uint32_t tag;
+ ptr = _upb_Decoder_DecodeTag(d, ptr, &tag);
+ switch (tag) {
+ case kEndItemTag:
+ return ptr;
+ case kTypeIdTag: {
+ uint64_t tmp;
+ ptr = _upb_Decoder_DecodeVarint(d, ptr, &tmp);
+ if (state_mask & kUpb_HaveId) break; // Ignore dup.
+ state_mask |= kUpb_HaveId;
+ type_id = tmp;
+ if (state_mask & kUpb_HavePayload) {
+ upb_Decoder_AddMessageSetItem(d, msg, layout, type_id, preserved.data,
+ preserved.size);
+ }
+ break;
+ }
+ case kMessageTag: {
+ uint32_t size;
+ ptr = upb_Decoder_DecodeSize(d, ptr, &size);
+ const char* data = ptr;
+ ptr += size;
+ if (state_mask & kUpb_HavePayload) break; // Ignore dup.
+ state_mask |= kUpb_HavePayload;
+ if (state_mask & kUpb_HaveId) {
+ upb_Decoder_AddMessageSetItem(d, msg, layout, type_id, data, size);
+ } else {
+ // Out of order, we must preserve the payload.
+ preserved.data = data;
+ preserved.size = size;
+ }
+ break;
+ }
+ default:
+ // We do not preserve unexpected fields inside a message set item.
+ ptr = upb_Decoder_SkipField(d, ptr, tag);
+ break;
+ }
+ }
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
+}
+
+static const upb_MiniTable_Field* _upb_Decoder_FindField(
+ upb_Decoder* d, const upb_MiniTable* l, uint32_t field_number,
+ int* last_field_index) {
+ static upb_MiniTable_Field none = {
+ 0, 0, 0, 0, kUpb_FakeFieldType_FieldNotFound, 0};
+ if (l == NULL) return &none;
+
+ size_t idx = ((size_t)field_number) - 1; // 0 wraps to SIZE_MAX
+ if (idx < l->dense_below) {
+ /* Fastest case: index into dense fields. */
+ goto found;
+ }
+
+ if (l->dense_below < l->field_count) {
+ /* Linear search non-dense fields. Resume scanning from last_field_index
+ * since fields are usually in order. */
+ int last = *last_field_index;
+ for (idx = last; idx < l->field_count; idx++) {
+ if (l->fields[idx].number == field_number) {
+ goto found;
+ }
+ }
+
+ for (idx = l->dense_below; idx < last; idx++) {
+ if (l->fields[idx].number == field_number) {
+ goto found;
+ }
+ }
+ }
+
+ if (d->extreg) {
+ switch (l->ext) {
+ case kUpb_ExtMode_Extendable: {
+ const upb_MiniTable_Extension* ext =
+ _upb_extreg_get(d->extreg, l, field_number);
+ if (ext) return &ext->field;
+ break;
+ }
+ case kUpb_ExtMode_IsMessageSet:
+ if (field_number == _UPB_MSGSET_ITEM) {
+ static upb_MiniTable_Field item = {
+ 0, 0, 0, 0, kUpb_FakeFieldType_MessageSetItem, 0};
+ return &item;
+ }
+ break;
+ }
+ }
+
+ return &none; /* Unknown field. */
+
+found:
+ UPB_ASSERT(l->fields[idx].number == field_number);
+ *last_field_index = idx;
+ return &l->fields[idx];
+}
+
+int _upb_Decoder_GetVarintOp(const upb_MiniTable_Field* field) {
+ static const int8_t kVarintOps[] = {
+ [kUpb_FakeFieldType_FieldNotFound] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Double] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Float] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Int64] = kUpb_DecodeOp_Scalar8Byte,
+ [kUpb_FieldType_UInt64] = kUpb_DecodeOp_Scalar8Byte,
+ [kUpb_FieldType_Int32] = kUpb_DecodeOp_Scalar4Byte,
+ [kUpb_FieldType_Fixed64] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Fixed32] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Bool] = kUpb_DecodeOp_Scalar1Byte,
+ [kUpb_FieldType_String] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Group] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Message] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Bytes] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_UInt32] = kUpb_DecodeOp_Scalar4Byte,
+ [kUpb_FieldType_Enum] = kUpb_DecodeOp_Enum,
+ [kUpb_FieldType_SFixed32] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_SFixed64] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_SInt32] = kUpb_DecodeOp_Scalar4Byte,
+ [kUpb_FieldType_SInt64] = kUpb_DecodeOp_Scalar8Byte,
+ [kUpb_FakeFieldType_MessageSetItem] = kUpb_DecodeOp_UnknownField,
+ };
+
+ return kVarintOps[field->descriptortype];
+}
+
+int _upb_Decoder_GetDelimitedOp(const upb_MiniTable* mt,
+ const upb_MiniTable_Field* field) {
+ enum { kRepeatedBase = 19 };
+
+ static const int8_t kDelimitedOps[] = {
+ /* For non-repeated field type. */
+ [kUpb_FakeFieldType_FieldNotFound] =
+ kUpb_DecodeOp_UnknownField, // Field not found.
+ [kUpb_FieldType_Double] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Float] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Int64] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_UInt64] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Int32] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Fixed64] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Fixed32] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Bool] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_String] = kUpb_DecodeOp_String,
+ [kUpb_FieldType_Group] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Message] = kUpb_DecodeOp_SubMessage,
+ [kUpb_FieldType_Bytes] = kUpb_DecodeOp_Bytes,
+ [kUpb_FieldType_UInt32] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_Enum] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_SFixed32] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_SFixed64] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_SInt32] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FieldType_SInt64] = kUpb_DecodeOp_UnknownField,
+ [kUpb_FakeFieldType_MessageSetItem] = kUpb_DecodeOp_UnknownField,
+ // For repeated field type. */
+ [kRepeatedBase + kUpb_FieldType_Double] = OP_FIXPCK_LG2(3),
+ [kRepeatedBase + kUpb_FieldType_Float] = OP_FIXPCK_LG2(2),
+ [kRepeatedBase + kUpb_FieldType_Int64] = OP_VARPCK_LG2(3),
+ [kRepeatedBase + kUpb_FieldType_UInt64] = OP_VARPCK_LG2(3),
+ [kRepeatedBase + kUpb_FieldType_Int32] = OP_VARPCK_LG2(2),
+ [kRepeatedBase + kUpb_FieldType_Fixed64] = OP_FIXPCK_LG2(3),
+ [kRepeatedBase + kUpb_FieldType_Fixed32] = OP_FIXPCK_LG2(2),
+ [kRepeatedBase + kUpb_FieldType_Bool] = OP_VARPCK_LG2(0),
+ [kRepeatedBase + kUpb_FieldType_String] = kUpb_DecodeOp_String,
+ [kRepeatedBase + kUpb_FieldType_Group] = kUpb_DecodeOp_SubMessage,
+ [kRepeatedBase + kUpb_FieldType_Message] = kUpb_DecodeOp_SubMessage,
+ [kRepeatedBase + kUpb_FieldType_Bytes] = kUpb_DecodeOp_Bytes,
+ [kRepeatedBase + kUpb_FieldType_UInt32] = OP_VARPCK_LG2(2),
+ [kRepeatedBase + kUpb_FieldType_Enum] = kUpb_DecodeOp_PackedEnum,
+ [kRepeatedBase + kUpb_FieldType_SFixed32] = OP_FIXPCK_LG2(2),
+ [kRepeatedBase + kUpb_FieldType_SFixed64] = OP_FIXPCK_LG2(3),
+ [kRepeatedBase + kUpb_FieldType_SInt32] = OP_VARPCK_LG2(2),
+ [kRepeatedBase + kUpb_FieldType_SInt64] = OP_VARPCK_LG2(3),
+ // Omitting kUpb_FakeFieldType_MessageSetItem, because we never emit a
+ // repeated msgset type
+ };
+
+ int ndx = field->descriptortype;
+ if (upb_FieldMode_Get(field) == kUpb_FieldMode_Array) ndx += kRepeatedBase;
+ int op = kDelimitedOps[ndx];
+
+ // If sub-message is not linked, treat as unknown.
+ if (op == kUpb_DecodeOp_SubMessage &&
+ !(field->mode & kUpb_LabelFlags_IsExtension)) {
+ const upb_MiniTable_Sub* sub = &mt->subs[field->submsg_index];
+ if (!sub->submsg) {
+ op = kUpb_DecodeOp_UnknownField;
+ }
+ }
+
+ return op;
+}
+
+UPB_FORCEINLINE
+static const char* _upb_Decoder_DecodeWireValue(
+ upb_Decoder* d, const char* ptr, const upb_MiniTable* mt,
+ const upb_MiniTable_Field* field, int wire_type, wireval* val, int* op) {
+ static const unsigned kFixed32OkMask = (1 << kUpb_FieldType_Float) |
+ (1 << kUpb_FieldType_Fixed32) |
+ (1 << kUpb_FieldType_SFixed32);
+
+ static const unsigned kFixed64OkMask = (1 << kUpb_FieldType_Double) |
+ (1 << kUpb_FieldType_Fixed64) |
+ (1 << kUpb_FieldType_SFixed64);
+
+ switch (wire_type) {
+ case kUpb_WireType_Varint:
+ ptr = _upb_Decoder_DecodeVarint(d, ptr, &val->uint64_val);
+ *op = _upb_Decoder_GetVarintOp(field);
+ _upb_Decoder_Munge(field->descriptortype, val);
+ return ptr;
+ case kUpb_WireType_32Bit:
+ memcpy(&val->uint32_val, ptr, 4);
+ val->uint32_val = _upb_BigEndian_Swap32(val->uint32_val);
+ *op = kUpb_DecodeOp_Scalar4Byte;
+ if (((1 << field->descriptortype) & kFixed32OkMask) == 0) {
+ *op = kUpb_DecodeOp_UnknownField;
+ }
+ return ptr + 4;
+ case kUpb_WireType_64Bit:
+ memcpy(&val->uint64_val, ptr, 8);
+ val->uint64_val = _upb_BigEndian_Swap64(val->uint64_val);
+ *op = kUpb_DecodeOp_Scalar8Byte;
+ if (((1 << field->descriptortype) & kFixed64OkMask) == 0) {
+ *op = kUpb_DecodeOp_UnknownField;
+ }
+ return ptr + 8;
+ case kUpb_WireType_Delimited:
+ ptr = upb_Decoder_DecodeSize(d, ptr, &val->size);
+ *op = _upb_Decoder_GetDelimitedOp(mt, field);
+ return ptr;
+ case kUpb_WireType_StartGroup:
+ val->uint32_val = field->number;
+ if (field->descriptortype == kUpb_FieldType_Group) {
+ *op = kUpb_DecodeOp_SubMessage;
+ } else if (field->descriptortype == kUpb_FakeFieldType_MessageSetItem) {
+ *op = kUpb_DecodeOp_MessageSetItem;
+ } else {
+ *op = kUpb_DecodeOp_UnknownField;
+ }
+ return ptr;
+ default:
+ break;
+ }
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
+}
+
+UPB_FORCEINLINE
+static const char* _upb_Decoder_DecodeKnownField(
+ upb_Decoder* d, const char* ptr, upb_Message* msg,
+ const upb_MiniTable* layout, const upb_MiniTable_Field* field, int op,
+ wireval* val) {
+ const upb_MiniTable_Sub* subs = layout->subs;
+ uint8_t mode = field->mode;
+
+ if (UPB_UNLIKELY(mode & kUpb_LabelFlags_IsExtension)) {
+ const upb_MiniTable_Extension* ext_layout =
+ (const upb_MiniTable_Extension*)field;
+ upb_Message_Extension* ext =
+ _upb_Message_GetOrCreateExtension(msg, ext_layout, &d->arena);
+ if (UPB_UNLIKELY(!ext)) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ }
+ d->unknown_msg = msg;
+ msg = &ext->data;
+ subs = &ext->ext->sub;
+ }
+
+ switch (mode & kUpb_FieldMode_Mask) {
+ case kUpb_FieldMode_Array:
+ return _upb_Decoder_DecodeToArray(d, ptr, msg, subs, field, val, op);
+ case kUpb_FieldMode_Map:
+ return _upb_Decoder_DecodeToMap(d, ptr, msg, subs, field, val);
+ case kUpb_FieldMode_Scalar:
+ return _upb_Decoder_DecodeToSubMessage(d, ptr, msg, subs, field, val, op);
+ default:
+ UPB_UNREACHABLE();
+ }
+}
+
+static const char* _upb_Decoder_ReverseSkipVarint(const char* ptr,
+ uint32_t val) {
+ uint32_t seen = 0;
+ do {
+ ptr--;
+ seen <<= 7;
+ seen |= *ptr & 0x7f;
+ } while (seen != val);
+ return ptr;
+}
+
+static const char* _upb_Decoder_DecodeUnknownField(upb_Decoder* d,
+ const char* ptr,
+ upb_Message* msg,
+ int field_number,
+ int wire_type, wireval val) {
+ if (field_number == 0) _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
+
+ // Since unknown fields are the uncommon case, we do a little extra work here
+ // to walk backwards through the buffer to find the field start. This frees
+ // up a register in the fast paths (when the field is known), which leads to
+ // significant speedups in benchmarks.
+ const char* start = ptr;
+
+ if (wire_type == kUpb_WireType_Delimited) ptr += val.size;
+ if (msg) {
+ switch (wire_type) {
+ case kUpb_WireType_Varint:
+ case kUpb_WireType_Delimited:
+ start--;
+ while (start[-1] & 0x80) start--;
+ break;
+ case kUpb_WireType_32Bit:
+ start -= 4;
+ break;
+ case kUpb_WireType_64Bit:
+ start -= 8;
+ break;
+ default:
+ break;
+ }
+
+ assert(start == d->debug_valstart);
+ uint32_t tag = ((uint32_t)field_number << 3) | wire_type;
+ start = _upb_Decoder_ReverseSkipVarint(start, tag);
+ assert(start == d->debug_tagstart);
+
+ if (wire_type == kUpb_WireType_StartGroup) {
+ d->unknown = start;
+ d->unknown_msg = msg;
+ ptr = _upb_Decoder_DecodeUnknownGroup(d, ptr, field_number);
+ start = d->unknown;
+ d->unknown = NULL;
+ }
+ if (!_upb_Message_AddUnknown(msg, start, ptr - start, &d->arena)) {
+ _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
+ }
+ } else if (wire_type == kUpb_WireType_StartGroup) {
+ ptr = _upb_Decoder_DecodeUnknownGroup(d, ptr, field_number);
+ }
+ return ptr;
+}
+
+UPB_NOINLINE
+static const char* _upb_Decoder_DecodeMessage(upb_Decoder* d, const char* ptr,
+ upb_Message* msg,
+ const upb_MiniTable* layout) {
+ int last_field_index = 0;
+
+#if UPB_FASTTABLE
+ // The first time we want to skip fast dispatch, because we may have just been
+ // invoked by the fast parser to handle a case that it bailed on.
+ if (!_upb_Decoder_IsDone(d, &ptr)) goto nofast;
+#endif
+
+ while (!_upb_Decoder_IsDone(d, &ptr)) {
+ uint32_t tag;
+ const upb_MiniTable_Field* field;
+ int field_number;
+ int wire_type;
+ wireval val;
+ int op;
+
+ if (_upb_Decoder_TryFastDispatch(d, &ptr, msg, layout)) break;
+
+#if UPB_FASTTABLE
+ nofast:
+#endif
+
+#ifndef NDEBUG
+ d->debug_tagstart = ptr;
+#endif
+
+ UPB_ASSERT(ptr < d->limit_ptr);
+ ptr = _upb_Decoder_DecodeTag(d, ptr, &tag);
+ field_number = tag >> 3;
+ wire_type = tag & 7;
+
+#ifndef NDEBUG
+ d->debug_valstart = ptr;
+#endif
+
+ if (wire_type == kUpb_WireType_EndGroup) {
+ d->end_group = field_number;
+ return ptr;
+ }
+
+ field = _upb_Decoder_FindField(d, layout, field_number, &last_field_index);
+ ptr = _upb_Decoder_DecodeWireValue(d, ptr, layout, field, wire_type, &val,
+ &op);
+
+ if (op >= 0) {
+ ptr = _upb_Decoder_DecodeKnownField(d, ptr, msg, layout, field, op, &val);
+ } else {
+ switch (op) {
+ case kUpb_DecodeOp_UnknownField:
+ ptr = _upb_Decoder_DecodeUnknownField(d, ptr, msg, field_number,
+ wire_type, val);
+ break;
+ case kUpb_DecodeOp_MessageSetItem:
+ ptr = upb_Decoder_DecodeMessageSetItem(d, ptr, msg, layout);
+ break;
+ }
+ }
+ }
+
+ return UPB_UNLIKELY(layout && layout->required_count)
+ ? _upb_Decoder_CheckRequired(d, ptr, msg, layout)
+ : ptr;
+}
+
+const char* _upb_FastDecoder_DecodeGeneric(struct upb_Decoder* d,
+ const char* ptr, upb_Message* msg,
+ intptr_t table, uint64_t hasbits,
+ uint64_t data) {
+ (void)data;
+ *(uint32_t*)msg |= hasbits;
+ return _upb_Decoder_DecodeMessage(d, ptr, msg, decode_totablep(table));
+}
+
+static upb_DecodeStatus _upb_Decoder_DecodeTop(struct upb_Decoder* d,
+ const char* buf, void* msg,
+ const upb_MiniTable* l) {
+ if (!_upb_Decoder_TryFastDispatch(d, &buf, msg, l)) {
+ _upb_Decoder_DecodeMessage(d, buf, msg, l);
+ }
+ if (d->end_group != DECODE_NOGROUP) return kUpb_DecodeStatus_Malformed;
+ if (d->missing_required) return kUpb_DecodeStatus_MissingRequired;
+ return kUpb_DecodeStatus_Ok;
+}
+
+upb_DecodeStatus upb_Decode(const char* buf, size_t size, void* msg,
+ const upb_MiniTable* l,
+ const upb_ExtensionRegistry* extreg, int options,
+ upb_Arena* arena) {
+ upb_Decoder state;
+ unsigned depth = (unsigned)options >> 16;
+
+ if (size <= 16) {
+ memset(&state.patch, 0, 32);
+ if (size) memcpy(&state.patch, buf, size);
+ buf = state.patch;
+ state.end = buf + size;
+ state.limit = 0;
+ options &= ~kUpb_DecodeOption_AliasString; // Can't alias patch buf.
+ } else {
+ state.end = buf + size - 16;
+ state.limit = 16;
+ }
+
+ state.extreg = extreg;
+ state.limit_ptr = state.end;
+ state.unknown = NULL;
+ state.depth = depth ? depth : 64;
+ state.end_group = DECODE_NOGROUP;
+ state.options = (uint16_t)options;
+ state.missing_required = false;
+ state.arena.head = arena->head;
+ state.arena.last_size = arena->last_size;
+ state.arena.cleanup_metadata = arena->cleanup_metadata;
+ state.arena.parent = arena;
+
+ upb_DecodeStatus status = UPB_SETJMP(state.err);
+ if (UPB_LIKELY(status == kUpb_DecodeStatus_Ok)) {
+ status = _upb_Decoder_DecodeTop(&state, buf, msg, l);
+ }
+
+ arena->head.ptr = state.arena.head.ptr;
+ arena->head.end = state.arena.head.end;
+ arena->cleanup_metadata = state.arena.cleanup_metadata;
+ return status;
+}
+
+#undef OP_FIXPCK_LG2
+#undef OP_VARPCK_LG2
+
+/* We encode backwards, to avoid pre-computing lengths (one-pass encode). */
+
+
+#include <string.h>
+
+
+// Must be last.
+
+#define UPB_PB_VARINT_MAX_LEN 10
+
+UPB_NOINLINE
+static size_t encode_varint64(uint64_t val, char* buf) {
+ size_t i = 0;
+ do {
+ uint8_t byte = val & 0x7fU;
+ val >>= 7;
+ if (val) byte |= 0x80U;
+ buf[i++] = byte;
+ } while (val);
+ return i;
+}
+
+static uint32_t encode_zz32(int32_t n) {
+ return ((uint32_t)n << 1) ^ (n >> 31);
+}
+static uint64_t encode_zz64(int64_t n) {
+ return ((uint64_t)n << 1) ^ (n >> 63);
+}
+
+typedef struct {
+ jmp_buf err;
+ upb_Arena* arena;
+ char *buf, *ptr, *limit;
+ int options;
+ int depth;
+ _upb_mapsorter sorter;
+} upb_encstate;
+
+static size_t upb_roundup_pow2(size_t bytes) {
+ size_t ret = 128;
+ while (ret < bytes) {
+ ret *= 2;
+ }
+ return ret;
+}
+
+UPB_NORETURN static void encode_err(upb_encstate* e, upb_EncodeStatus s) {
+ UPB_LONGJMP(e->err, s);
+}
+
+UPB_NOINLINE
+static void encode_growbuffer(upb_encstate* e, size_t bytes) {
+ size_t old_size = e->limit - e->buf;
+ size_t new_size = upb_roundup_pow2(bytes + (e->limit - e->ptr));
+ char* new_buf = upb_Arena_Realloc(e->arena, e->buf, old_size, new_size);
+
+ if (!new_buf) encode_err(e, kUpb_EncodeStatus_OutOfMemory);
+
+ // We want previous data at the end, realloc() put it at the beginning.
+ // TODO(salo): This is somewhat inefficient since we are copying twice.
+ // Maybe create a realloc() that copies to the end of the new buffer?
+ if (old_size > 0) {
+ memmove(new_buf + new_size - old_size, e->buf, old_size);
+ }
+
+ e->ptr = new_buf + new_size - (e->limit - e->ptr);
+ e->limit = new_buf + new_size;
+ e->buf = new_buf;
+
+ e->ptr -= bytes;
+}
+
+/* Call to ensure that at least "bytes" bytes are available for writing at
+ * e->ptr. Returns false if the bytes could not be allocated. */
+UPB_FORCEINLINE
+static void encode_reserve(upb_encstate* e, size_t bytes) {
+ if ((size_t)(e->ptr - e->buf) < bytes) {
+ encode_growbuffer(e, bytes);
+ return;
+ }
+
+ e->ptr -= bytes;
+}
+
+/* Writes the given bytes to the buffer, handling reserve/advance. */
+static void encode_bytes(upb_encstate* e, const void* data, size_t len) {
+ if (len == 0) return; /* memcpy() with zero size is UB */
+ encode_reserve(e, len);
+ memcpy(e->ptr, data, len);
+}
+
+static void encode_fixed64(upb_encstate* e, uint64_t val) {
+ val = _upb_BigEndian_Swap64(val);
+ encode_bytes(e, &val, sizeof(uint64_t));
+}
+
+static void encode_fixed32(upb_encstate* e, uint32_t val) {
+ val = _upb_BigEndian_Swap32(val);
+ encode_bytes(e, &val, sizeof(uint32_t));
+}
+
+UPB_NOINLINE
+static void encode_longvarint(upb_encstate* e, uint64_t val) {
+ size_t len;
+ char* start;
+
+ encode_reserve(e, UPB_PB_VARINT_MAX_LEN);
+ len = encode_varint64(val, e->ptr);
+ start = e->ptr + UPB_PB_VARINT_MAX_LEN - len;
+ memmove(start, e->ptr, len);
+ e->ptr = start;
+}
+
+UPB_FORCEINLINE
+static void encode_varint(upb_encstate* e, uint64_t val) {
+ if (val < 128 && e->ptr != e->buf) {
+ --e->ptr;
+ *e->ptr = val;
+ } else {
+ encode_longvarint(e, val);
+ }
+}
+
+static void encode_double(upb_encstate* e, double d) {
+ uint64_t u64;
+ UPB_ASSERT(sizeof(double) == sizeof(uint64_t));
+ memcpy(&u64, &d, sizeof(uint64_t));
+ encode_fixed64(e, u64);
+}
+
+static void encode_float(upb_encstate* e, float d) {
+ uint32_t u32;
+ UPB_ASSERT(sizeof(float) == sizeof(uint32_t));
+ memcpy(&u32, &d, sizeof(uint32_t));
+ encode_fixed32(e, u32);
+}
+
+static void encode_tag(upb_encstate* e, uint32_t field_number,
+ uint8_t wire_type) {
+ encode_varint(e, (field_number << 3) | wire_type);
+}
+
+static void encode_fixedarray(upb_encstate* e, const upb_Array* arr,
+ size_t elem_size, uint32_t tag) {
+ size_t bytes = arr->size * elem_size;
+ const char* data = _upb_array_constptr(arr);
+ const char* ptr = data + bytes - elem_size;
+
+ if (tag || !_upb_IsLittleEndian()) {
+ while (true) {
+ if (elem_size == 4) {
+ uint32_t val;
+ memcpy(&val, ptr, sizeof(val));
+ val = _upb_BigEndian_Swap32(val);
+ encode_bytes(e, &val, elem_size);
+ } else {
+ UPB_ASSERT(elem_size == 8);
+ uint64_t val;
+ memcpy(&val, ptr, sizeof(val));
+ val = _upb_BigEndian_Swap64(val);
+ encode_bytes(e, &val, elem_size);
+ }
+
+ if (tag) encode_varint(e, tag);
+ if (ptr == data) break;
+ ptr -= elem_size;
+ }
+ } else {
+ encode_bytes(e, data, bytes);
+ }
+}
+
+static void encode_message(upb_encstate* e, const upb_Message* msg,
+ const upb_MiniTable* m, size_t* size);
+
+static void encode_scalar(upb_encstate* e, const void* _field_mem,
+ const upb_MiniTable_Sub* subs,
+ const upb_MiniTable_Field* f) {
+ const char* field_mem = _field_mem;
+ int wire_type;
+
+#define CASE(ctype, type, wtype, encodeval) \
+ { \
+ ctype val = *(ctype*)field_mem; \
+ encode_##type(e, encodeval); \
+ wire_type = wtype; \
+ break; \
+ }
+
+ switch (f->descriptortype) {
+ case kUpb_FieldType_Double:
+ CASE(double, double, kUpb_WireType_64Bit, val);
+ case kUpb_FieldType_Float:
+ CASE(float, float, kUpb_WireType_32Bit, val);
+ case kUpb_FieldType_Int64:
+ case kUpb_FieldType_UInt64:
+ CASE(uint64_t, varint, kUpb_WireType_Varint, val);
+ case kUpb_FieldType_UInt32:
+ CASE(uint32_t, varint, kUpb_WireType_Varint, val);
+ case kUpb_FieldType_Int32:
+ case kUpb_FieldType_Enum:
+ CASE(int32_t, varint, kUpb_WireType_Varint, (int64_t)val);
+ case kUpb_FieldType_SFixed64:
+ case kUpb_FieldType_Fixed64:
+ CASE(uint64_t, fixed64, kUpb_WireType_64Bit, val);
+ case kUpb_FieldType_Fixed32:
+ case kUpb_FieldType_SFixed32:
+ CASE(uint32_t, fixed32, kUpb_WireType_32Bit, val);
+ case kUpb_FieldType_Bool:
+ CASE(bool, varint, kUpb_WireType_Varint, val);
+ case kUpb_FieldType_SInt32:
+ CASE(int32_t, varint, kUpb_WireType_Varint, encode_zz32(val));
+ case kUpb_FieldType_SInt64:
+ CASE(int64_t, varint, kUpb_WireType_Varint, encode_zz64(val));
+ case kUpb_FieldType_String:
+ case kUpb_FieldType_Bytes: {
+ upb_StringView view = *(upb_StringView*)field_mem;
+ encode_bytes(e, view.data, view.size);
+ encode_varint(e, view.size);
+ wire_type = kUpb_WireType_Delimited;
+ break;
+ }
+ case kUpb_FieldType_Group: {
+ size_t size;
+ void* submsg = *(void**)field_mem;
+ const upb_MiniTable* subm = subs[f->submsg_index].submsg;
+ if (submsg == NULL) {
+ return;
+ }
+ if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
+ encode_tag(e, f->number, kUpb_WireType_EndGroup);
+ encode_message(e, submsg, subm, &size);
+ wire_type = kUpb_WireType_StartGroup;
+ e->depth++;
+ break;
+ }
+ case kUpb_FieldType_Message: {
+ size_t size;
+ void* submsg = *(void**)field_mem;
+ const upb_MiniTable* subm = subs[f->submsg_index].submsg;
+ if (submsg == NULL) {
+ return;
+ }
+ if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
+ encode_message(e, submsg, subm, &size);
+ encode_varint(e, size);
+ wire_type = kUpb_WireType_Delimited;
+ e->depth++;
+ break;
+ }
+ default:
+ UPB_UNREACHABLE();
+ }
+#undef CASE
+
+ encode_tag(e, f->number, wire_type);
+}
+
+static void encode_array(upb_encstate* e, const upb_Message* msg,
+ const upb_MiniTable_Sub* subs,
+ const upb_MiniTable_Field* f) {
+ const upb_Array* arr = *UPB_PTR_AT(msg, f->offset, upb_Array*);
+ bool packed = f->mode & kUpb_LabelFlags_IsPacked;
+ size_t pre_len = e->limit - e->ptr;
+
+ if (arr == NULL || arr->size == 0) {
+ return;
+ }
+
+#define VARINT_CASE(ctype, encode) \
+ { \
+ const ctype* start = _upb_array_constptr(arr); \
+ const ctype* ptr = start + arr->size; \
+ uint32_t tag = packed ? 0 : (f->number << 3) | kUpb_WireType_Varint; \
+ do { \
+ ptr--; \
+ encode_varint(e, encode); \
+ if (tag) encode_varint(e, tag); \
+ } while (ptr != start); \
+ } \
+ break;
+
+#define TAG(wire_type) (packed ? 0 : (f->number << 3 | wire_type))
+
+ switch (f->descriptortype) {
+ case kUpb_FieldType_Double:
+ encode_fixedarray(e, arr, sizeof(double), TAG(kUpb_WireType_64Bit));
+ break;
+ case kUpb_FieldType_Float:
+ encode_fixedarray(e, arr, sizeof(float), TAG(kUpb_WireType_32Bit));
+ break;
+ case kUpb_FieldType_SFixed64:
+ case kUpb_FieldType_Fixed64:
+ encode_fixedarray(e, arr, sizeof(uint64_t), TAG(kUpb_WireType_64Bit));
+ break;
+ case kUpb_FieldType_Fixed32:
+ case kUpb_FieldType_SFixed32:
+ encode_fixedarray(e, arr, sizeof(uint32_t), TAG(kUpb_WireType_32Bit));
+ break;
+ case kUpb_FieldType_Int64:
+ case kUpb_FieldType_UInt64:
+ VARINT_CASE(uint64_t, *ptr);
+ case kUpb_FieldType_UInt32:
+ VARINT_CASE(uint32_t, *ptr);
+ case kUpb_FieldType_Int32:
+ case kUpb_FieldType_Enum:
+ VARINT_CASE(int32_t, (int64_t)*ptr);
+ case kUpb_FieldType_Bool:
+ VARINT_CASE(bool, *ptr);
+ case kUpb_FieldType_SInt32:
+ VARINT_CASE(int32_t, encode_zz32(*ptr));
+ case kUpb_FieldType_SInt64:
+ VARINT_CASE(int64_t, encode_zz64(*ptr));
+ case kUpb_FieldType_String:
+ case kUpb_FieldType_Bytes: {
+ const upb_StringView* start = _upb_array_constptr(arr);
+ const upb_StringView* ptr = start + arr->size;
+ do {
+ ptr--;
+ encode_bytes(e, ptr->data, ptr->size);
+ encode_varint(e, ptr->size);
+ encode_tag(e, f->number, kUpb_WireType_Delimited);
+ } while (ptr != start);
+ return;
+ }
+ case kUpb_FieldType_Group: {
+ const void* const* start = _upb_array_constptr(arr);
+ const void* const* ptr = start + arr->size;
+ const upb_MiniTable* subm = subs[f->submsg_index].submsg;
+ if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
+ do {
+ size_t size;
+ ptr--;
+ encode_tag(e, f->number, kUpb_WireType_EndGroup);
+ encode_message(e, *ptr, subm, &size);
+ encode_tag(e, f->number, kUpb_WireType_StartGroup);
+ } while (ptr != start);
+ e->depth++;
+ return;
+ }
+ case kUpb_FieldType_Message: {
+ const void* const* start = _upb_array_constptr(arr);
+ const void* const* ptr = start + arr->size;
+ const upb_MiniTable* subm = subs[f->submsg_index].submsg;
+ if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
+ do {
+ size_t size;
+ ptr--;
+ encode_message(e, *ptr, subm, &size);
+ encode_varint(e, size);
+ encode_tag(e, f->number, kUpb_WireType_Delimited);
+ } while (ptr != start);
+ e->depth++;
+ return;
+ }
+ }
+#undef VARINT_CASE
+
+ if (packed) {
+ encode_varint(e, e->limit - e->ptr - pre_len);
+ encode_tag(e, f->number, kUpb_WireType_Delimited);
+ }
+}
+
+static void encode_mapentry(upb_encstate* e, uint32_t number,
+ const upb_MiniTable* layout,
+ const upb_MapEntry* ent) {
+ const upb_MiniTable_Field* key_field = &layout->fields[0];
+ const upb_MiniTable_Field* val_field = &layout->fields[1];
+ size_t pre_len = e->limit - e->ptr;
+ size_t size;
+ encode_scalar(e, &ent->v, layout->subs, val_field);
+ encode_scalar(e, &ent->k, layout->subs, key_field);
+ size = (e->limit - e->ptr) - pre_len;
+ encode_varint(e, size);
+ encode_tag(e, number, kUpb_WireType_Delimited);
+}
+
+static void encode_map(upb_encstate* e, const upb_Message* msg,
+ const upb_MiniTable_Sub* subs,
+ const upb_MiniTable_Field* f) {
+ const upb_Map* map = *UPB_PTR_AT(msg, f->offset, const upb_Map*);
+ const upb_MiniTable* layout = subs[f->submsg_index].submsg;
+ UPB_ASSERT(layout->field_count == 2);
+
+ if (map == NULL) return;
+
+ if (e->options & kUpb_EncodeOption_Deterministic) {
+ _upb_sortedmap sorted;
+ _upb_mapsorter_pushmap(&e->sorter, layout->fields[0].descriptortype, map,
+ &sorted);
+ upb_MapEntry ent;
+ while (_upb_sortedmap_next(&e->sorter, map, &sorted, &ent)) {
+ encode_mapentry(e, f->number, layout, &ent);
+ }
+ _upb_mapsorter_popmap(&e->sorter, &sorted);
+ } else {
+ upb_strtable_iter i;
+ upb_strtable_begin(&i, &map->table);
+ for (; !upb_strtable_done(&i); upb_strtable_next(&i)) {
+ upb_StringView key = upb_strtable_iter_key(&i);
+ const upb_value val = upb_strtable_iter_value(&i);
+ upb_MapEntry ent;
+ _upb_map_fromkey(key, &ent.k, map->key_size);
+ _upb_map_fromvalue(val, &ent.v, map->val_size);
+ encode_mapentry(e, f->number, layout, &ent);
+ }
+ }
+}
+
+static bool encode_shouldencode(upb_encstate* e, const upb_Message* msg,
+ const upb_MiniTable_Sub* subs,
+ const upb_MiniTable_Field* f) {
+ if (f->presence == 0) {
+ /* Proto3 presence or map/array. */
+ const void* mem = UPB_PTR_AT(msg, f->offset, void);
+ switch (f->mode >> kUpb_FieldRep_Shift) {
+ case kUpb_FieldRep_1Byte: {
+ char ch;
+ memcpy(&ch, mem, 1);
+ return ch != 0;
+ }
+#if UINTPTR_MAX == 0xffffffff
+ case kUpb_FieldRep_Pointer:
+#endif
+ case kUpb_FieldRep_4Byte: {
+ uint32_t u32;
+ memcpy(&u32, mem, 4);
+ return u32 != 0;
+ }
+#if UINTPTR_MAX != 0xffffffff
+ case kUpb_FieldRep_Pointer:
+#endif
+ case kUpb_FieldRep_8Byte: {
+ uint64_t u64;
+ memcpy(&u64, mem, 8);
+ return u64 != 0;
+ }
+ case kUpb_FieldRep_StringView: {
+ const upb_StringView* str = (const upb_StringView*)mem;
+ return str->size != 0;
+ }
+ default:
+ UPB_UNREACHABLE();
+ }
+ } else if (f->presence > 0) {
+ /* Proto2 presence: hasbit. */
+ return _upb_hasbit_field(msg, f);
+ } else {
+ /* Field is in a oneof. */
+ return _upb_getoneofcase_field(msg, f) == f->number;
+ }
+}
+
+static void encode_field(upb_encstate* e, const upb_Message* msg,
+ const upb_MiniTable_Sub* subs,
+ const upb_MiniTable_Field* field) {
+ switch (upb_FieldMode_Get(field)) {
+ case kUpb_FieldMode_Array:
+ encode_array(e, msg, subs, field);
+ break;
+ case kUpb_FieldMode_Map:
+ encode_map(e, msg, subs, field);
+ break;
+ case kUpb_FieldMode_Scalar:
+ encode_scalar(e, UPB_PTR_AT(msg, field->offset, void), subs, field);
+ break;
+ default:
+ UPB_UNREACHABLE();
+ }
+}
+
+/* message MessageSet {
+ * repeated group Item = 1 {
+ * required int32 type_id = 2;
+ * required string message = 3;
+ * }
+ * } */
+static void encode_msgset_item(upb_encstate* e,
+ const upb_Message_Extension* ext) {
+ size_t size;
+ encode_tag(e, 1, kUpb_WireType_EndGroup);
+ encode_message(e, ext->data.ptr, ext->ext->sub.submsg, &size);
+ encode_varint(e, size);
+ encode_tag(e, 3, kUpb_WireType_Delimited);
+ encode_varint(e, ext->ext->field.number);
+ encode_tag(e, 2, kUpb_WireType_Varint);
+ encode_tag(e, 1, kUpb_WireType_StartGroup);
+}
+
+static void encode_message(upb_encstate* e, const upb_Message* msg,
+ const upb_MiniTable* m, size_t* size) {
+ size_t pre_len = e->limit - e->ptr;
+
+ if ((e->options & kUpb_EncodeOption_CheckRequired) && m->required_count) {
+ uint64_t msg_head;
+ memcpy(&msg_head, msg, 8);
+ msg_head = _upb_BigEndian_Swap64(msg_head);
+ if (upb_MiniTable_requiredmask(m) & ~msg_head) {
+ encode_err(e, kUpb_EncodeStatus_MissingRequired);
+ }
+ }
+
+ if ((e->options & kUpb_EncodeOption_SkipUnknown) == 0) {
+ size_t unknown_size;
+ const char* unknown = upb_Message_GetUnknown(msg, &unknown_size);
+
+ if (unknown) {
+ encode_bytes(e, unknown, unknown_size);
+ }
+ }
+
+ if (m->ext != kUpb_ExtMode_NonExtendable) {
+ /* Encode all extensions together. Unlike C++, we do not attempt to keep
+ * these in field number order relative to normal fields or even to each
+ * other. */
+ size_t ext_count;
+ const upb_Message_Extension* ext = _upb_Message_Getexts(msg, &ext_count);
+ if (ext_count) {
+ const upb_Message_Extension* end = ext + ext_count;
+ for (; ext != end; ext++) {
+ if (UPB_UNLIKELY(m->ext == kUpb_ExtMode_IsMessageSet)) {
+ encode_msgset_item(e, ext);
+ } else {
+ encode_field(e, &ext->data, &ext->ext->sub, &ext->ext->field);
+ }
+ }
+ }
+ }
+
+ if (m->field_count) {
+ const upb_MiniTable_Field* f = &m->fields[m->field_count];
+ const upb_MiniTable_Field* first = &m->fields[0];
+ while (f != first) {
+ f--;
+ if (encode_shouldencode(e, msg, m->subs, f)) {
+ encode_field(e, msg, m->subs, f);
+ }
+ }
+ }
+
+ *size = (e->limit - e->ptr) - pre_len;
+}
+
+upb_EncodeStatus upb_Encode(const void* msg, const upb_MiniTable* l,
+ int options, upb_Arena* arena, char** buf,
+ size_t* size) {
+ upb_encstate e;
+ unsigned depth = (unsigned)options >> 16;
+
+ e.arena = arena;
+ e.buf = NULL;
+ e.limit = NULL;
+ e.ptr = NULL;
+ e.depth = depth ? depth : 64;
+ e.options = options;
+ _upb_mapsorter_init(&e.sorter);
+
+ upb_EncodeStatus status = UPB_SETJMP(e.err);
+
+ // Unfortunately we must continue to perform hackery here because there are
+ // code paths which blindly copy the returned pointer without bothering to
+ // check for errors until much later (b/235839510). So we still set *buf to
+ // NULL on error and we still set it to non-NULL on a successful empty result.
+ if (status == kUpb_EncodeStatus_Ok) {
+ encode_message(&e, msg, l, size);
+ *size = e.limit - e.ptr;
+ if (*size == 0) {
+ static char ch;
+ *buf = &ch;
+ } else {
+ UPB_ASSERT(e.ptr);
+ *buf = e.ptr;
+ }
+ } else {
+ *buf = NULL;
+ *size = 0;
+ }
+
+ _upb_mapsorter_destroy(&e.sorter);
+ return status;
+}
+
+
+#include <math.h>
+
+
+// Must be last.
+
+/** upb_Message ***************************************************************/
+
+static const size_t overhead = sizeof(upb_Message_InternalData);
+
+static const upb_Message_Internal* upb_Message_Getinternal_const(
+ const upb_Message* msg) {
+ ptrdiff_t size = sizeof(upb_Message_Internal);
+ return (upb_Message_Internal*)((char*)msg - size);
+}
+
+upb_Message* _upb_Message_New(const upb_MiniTable* l, upb_Arena* a) {
+ return _upb_Message_New_inl(l, a);
+}
+
+void _upb_Message_Clear(upb_Message* msg, const upb_MiniTable* l) {
+ void* mem = UPB_PTR_AT(msg, -sizeof(upb_Message_Internal), char);
+ memset(mem, 0, upb_msg_sizeof(l));
+}
+
+static bool realloc_internal(upb_Message* msg, size_t need, upb_Arena* arena) {
+ upb_Message_Internal* in = upb_Message_Getinternal(msg);
+ if (!in->internal) {
+ /* No internal data, allocate from scratch. */
+ size_t size = UPB_MAX(128, _upb_Log2CeilingSize(need + overhead));
+ upb_Message_InternalData* internal = upb_Arena_Malloc(arena, size);
+ if (!internal) return false;
+ internal->size = size;
+ internal->unknown_end = overhead;
+ internal->ext_begin = size;
+ in->internal = internal;
+ } else if (in->internal->ext_begin - in->internal->unknown_end < need) {
+ /* Internal data is too small, reallocate. */
+ size_t new_size = _upb_Log2CeilingSize(in->internal->size + need);
+ size_t ext_bytes = in->internal->size - in->internal->ext_begin;
+ size_t new_ext_begin = new_size - ext_bytes;
+ upb_Message_InternalData* internal =
+ upb_Arena_Realloc(arena, in->internal, in->internal->size, new_size);
+ if (!internal) return false;
+ if (ext_bytes) {
+ /* Need to move extension data to the end. */
+ char* ptr = (char*)internal;
+ memmove(ptr + new_ext_begin, ptr + internal->ext_begin, ext_bytes);
+ }
+ internal->ext_begin = new_ext_begin;
+ internal->size = new_size;
+ in->internal = internal;
+ }
+ UPB_ASSERT(in->internal->ext_begin - in->internal->unknown_end >= need);
+ return true;
+}
+
+bool _upb_Message_AddUnknown(upb_Message* msg, const char* data, size_t len,
+ upb_Arena* arena) {
+ if (!realloc_internal(msg, len, arena)) return false;
+ upb_Message_Internal* in = upb_Message_Getinternal(msg);
+ memcpy(UPB_PTR_AT(in->internal, in->internal->unknown_end, char), data, len);
+ in->internal->unknown_end += len;
+ return true;
+}
+
+void _upb_Message_DiscardUnknown_shallow(upb_Message* msg) {
+ upb_Message_Internal* in = upb_Message_Getinternal(msg);
+ if (in->internal) {
+ in->internal->unknown_end = overhead;
+ }
+}
+
+const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len) {
+ const upb_Message_Internal* in = upb_Message_Getinternal_const(msg);
+ if (in->internal) {
+ *len = in->internal->unknown_end - overhead;
+ return (char*)(in->internal + 1);
+ } else {
+ *len = 0;
+ return NULL;
+ }
+}
+
+const upb_Message_Extension* _upb_Message_Getexts(const upb_Message* msg,
+ size_t* count) {
+ const upb_Message_Internal* in = upb_Message_Getinternal_const(msg);
+ if (in->internal) {
+ *count = (in->internal->size - in->internal->ext_begin) /
+ sizeof(upb_Message_Extension);
+ return UPB_PTR_AT(in->internal, in->internal->ext_begin, void);
+ } else {
+ *count = 0;
+ return NULL;
+ }
+}
+
+const upb_Message_Extension* _upb_Message_Getext(
+ const upb_Message* msg, const upb_MiniTable_Extension* e) {
+ size_t n;
+ const upb_Message_Extension* ext = _upb_Message_Getexts(msg, &n);
+
+ /* For now we use linear search exclusively to find extensions. If this
+ * becomes an issue due to messages with lots of extensions, we can introduce
+ * a table of some sort. */
+ for (size_t i = 0; i < n; i++) {
+ if (ext[i].ext == e) {
+ return &ext[i];
+ }
+ }
+
+ return NULL;
+}
+
+void _upb_Message_Clearext(upb_Message* msg,
+ const upb_MiniTable_Extension* ext_l) {
+ upb_Message_Internal* in = upb_Message_Getinternal(msg);
+ if (!in->internal) return;
+ const upb_Message_Extension* base =
+ UPB_PTR_AT(in->internal, in->internal->ext_begin, void);
+ upb_Message_Extension* ext =
+ (upb_Message_Extension*)_upb_Message_Getext(msg, ext_l);
+ if (ext) {
+ *ext = *base;
+ in->internal->ext_begin += sizeof(upb_Message_Extension);
+ }
+}
+
+upb_Message_Extension* _upb_Message_GetOrCreateExtension(
+ upb_Message* msg, const upb_MiniTable_Extension* e, upb_Arena* arena) {
+ upb_Message_Extension* ext =
+ (upb_Message_Extension*)_upb_Message_Getext(msg, e);
+ if (ext) return ext;
+ if (!realloc_internal(msg, sizeof(upb_Message_Extension), arena)) return NULL;
+ upb_Message_Internal* in = upb_Message_Getinternal(msg);
+ in->internal->ext_begin -= sizeof(upb_Message_Extension);
+ ext = UPB_PTR_AT(in->internal, in->internal->ext_begin, void);
+ memset(ext, 0, sizeof(upb_Message_Extension));
+ ext->ext = e;
+ return ext;
+}
+
+size_t upb_Message_ExtensionCount(const upb_Message* msg) {
+ size_t count;
+ _upb_Message_Getexts(msg, &count);
+ return count;
+}
+
+/** upb_Map *******************************************************************/
+
+upb_Map* _upb_Map_New(upb_Arena* a, size_t key_size, size_t value_size) {
+ upb_Map* map = upb_Arena_Malloc(a, sizeof(upb_Map));
+
+ if (!map) {
+ return NULL;
+ }
+
+ upb_strtable_init(&map->table, 4, a);
+ map->key_size = key_size;
+ map->val_size = value_size;
+
+ return map;
+}
+
+static void _upb_mapsorter_getkeys(const void* _a, const void* _b, void* a_key,
+ void* b_key, size_t size) {
+ const upb_tabent* const* a = _a;
+ const upb_tabent* const* b = _b;
+ upb_StringView a_tabkey = upb_tabstrview((*a)->key);
+ upb_StringView b_tabkey = upb_tabstrview((*b)->key);
+ _upb_map_fromkey(a_tabkey, a_key, size);
+ _upb_map_fromkey(b_tabkey, b_key, size);
+}
+
+#define UPB_COMPARE_INTEGERS(a, b) ((a) < (b) ? -1 : ((a) == (b) ? 0 : 1))
+
+static int _upb_mapsorter_cmpi64(const void* _a, const void* _b) {
+ int64_t a, b;
+ _upb_mapsorter_getkeys(_a, _b, &a, &b, 8);
+ return UPB_COMPARE_INTEGERS(a, b);
+}
+
+static int _upb_mapsorter_cmpu64(const void* _a, const void* _b) {
+ uint64_t a, b;
+ _upb_mapsorter_getkeys(_a, _b, &a, &b, 8);
+ return UPB_COMPARE_INTEGERS(a, b);
+}
+
+static int _upb_mapsorter_cmpi32(const void* _a, const void* _b) {
+ int32_t a, b;
+ _upb_mapsorter_getkeys(_a, _b, &a, &b, 4);
+ return UPB_COMPARE_INTEGERS(a, b);
+}
+
+static int _upb_mapsorter_cmpu32(const void* _a, const void* _b) {
+ uint32_t a, b;
+ _upb_mapsorter_getkeys(_a, _b, &a, &b, 4);
+ return UPB_COMPARE_INTEGERS(a, b);
+}
+
+static int _upb_mapsorter_cmpbool(const void* _a, const void* _b) {
+ bool a, b;
+ _upb_mapsorter_getkeys(_a, _b, &a, &b, 1);
+ return UPB_COMPARE_INTEGERS(a, b);
+}
+
+static int _upb_mapsorter_cmpstr(const void* _a, const void* _b) {
+ upb_StringView a, b;
+ _upb_mapsorter_getkeys(_a, _b, &a, &b, UPB_MAPTYPE_STRING);
+ size_t common_size = UPB_MIN(a.size, b.size);
+ int cmp = memcmp(a.data, b.data, common_size);
+ if (cmp) return -cmp;
+ return UPB_COMPARE_INTEGERS(a.size, b.size);
+}
+
+#undef UPB_COMPARE_INTEGERS
+
+bool _upb_mapsorter_pushmap(_upb_mapsorter* s, upb_FieldType key_type,
+ const upb_Map* map, _upb_sortedmap* sorted) {
+ int map_size = _upb_Map_Size(map);
+ sorted->start = s->size;
+ sorted->pos = sorted->start;
+ sorted->end = sorted->start + map_size;
+
+ /* Grow s->entries if necessary. */
+ if (sorted->end > s->cap) {
+ s->cap = _upb_Log2CeilingSize(sorted->end);
+ s->entries = realloc(s->entries, s->cap * sizeof(*s->entries));
+ if (!s->entries) return false;
+ }
+
+ s->size = sorted->end;
+
+ /* Copy non-empty entries from the table to s->entries. */
+ upb_tabent const** dst = &s->entries[sorted->start];
+ const upb_tabent* src = map->table.t.entries;
+ const upb_tabent* end = src + upb_table_size(&map->table.t);
+ for (; src < end; src++) {
+ if (!upb_tabent_isempty(src)) {
+ *dst = src;
+ dst++;
+ }
+ }
+ UPB_ASSERT(dst == &s->entries[sorted->end]);
+
+ /* Sort entries according to the key type. */
+
+ int (*compar)(const void*, const void*);
+
+ switch (key_type) {
+ case kUpb_FieldType_Int64:
+ case kUpb_FieldType_SFixed64:
+ case kUpb_FieldType_SInt64:
+ compar = _upb_mapsorter_cmpi64;
+ break;
+ case kUpb_FieldType_UInt64:
+ case kUpb_FieldType_Fixed64:
+ compar = _upb_mapsorter_cmpu64;
+ break;
+ case kUpb_FieldType_Int32:
+ case kUpb_FieldType_SInt32:
+ case kUpb_FieldType_SFixed32:
+ case kUpb_FieldType_Enum:
+ compar = _upb_mapsorter_cmpi32;
+ break;
+ case kUpb_FieldType_UInt32:
+ case kUpb_FieldType_Fixed32:
+ compar = _upb_mapsorter_cmpu32;
+ break;
+ case kUpb_FieldType_Bool:
+ compar = _upb_mapsorter_cmpbool;
+ break;
+ case kUpb_FieldType_String:
+ case kUpb_FieldType_Bytes:
+ compar = _upb_mapsorter_cmpstr;
+ break;
+ default:
+ UPB_UNREACHABLE();
+ }
+
+ qsort(&s->entries[sorted->start], map_size, sizeof(*s->entries), compar);
+ return true;
+}
+
+const float kUpb_FltInfinity = INFINITY;
+const double kUpb_Infinity = INFINITY;
+
+
+#include <errno.h>
+#include <float.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Must be last.
+
+void upb_Status_Clear(upb_Status* status) {
+ if (!status) return;
+ status->ok = true;
+ status->msg[0] = '\0';
+}
+
+bool upb_Status_IsOk(const upb_Status* status) { return status->ok; }
+
+const char* upb_Status_ErrorMessage(const upb_Status* status) {
+ return status->msg;
+}
+
+void upb_Status_SetErrorMessage(upb_Status* status, const char* msg) {
+ if (!status) return;
+ status->ok = false;
+ strncpy(status->msg, msg, _kUpb_Status_MaxMessage - 1);
+ status->msg[_kUpb_Status_MaxMessage - 1] = '\0';
+}
+
+void upb_Status_SetErrorFormat(upb_Status* status, const char* fmt, ...) {
+ va_list args;
+ va_start(args, fmt);
+ upb_Status_VSetErrorFormat(status, fmt, args);
+ va_end(args);
+}
+
+void upb_Status_VSetErrorFormat(upb_Status* status, const char* fmt,
+ va_list args) {
+ if (!status) return;
+ status->ok = false;
+ vsnprintf(status->msg, sizeof(status->msg), fmt, args);
+ status->msg[_kUpb_Status_MaxMessage - 1] = '\0';
+}
+
+void upb_Status_VAppendErrorFormat(upb_Status* status, const char* fmt,
+ va_list args) {
+ size_t len;
+ if (!status) return;
+ status->ok = false;
+ len = strlen(status->msg);
+ vsnprintf(status->msg + len, sizeof(status->msg) - len, fmt, args);
+ status->msg[_kUpb_Status_MaxMessage - 1] = '\0';
+}
+
+#include <float.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+// Must be last.
+
/* Miscellaneous utilities ****************************************************/
static void upb_FixLocale(char* p) {
@@ -3567,7517 +12606,35 @@
upb_FixLocale(buf);
}
-/** upb/decode_fast.c ************************************************************/
-// Fast decoder: ~3x the speed of decode.c, but requires x86-64/ARM64.
-// Also the table size grows by 2x.
-//
-// Could potentially be ported to other 64-bit archs that pass at least six
-// arguments in registers and have 8 unused high bits in pointers.
-//
-// The overall design is to create specialized functions for every possible
-// field type (eg. oneof boolean field with a 1 byte tag) and then dispatch
-// to the specialized function as quickly as possible.
+// Must be last.
-
-/* Must be last. */
-
-#if UPB_FASTTABLE
-
-// The standard set of arguments passed to each parsing function.
-// Thanks to x86-64 calling conventions, these will stay in registers.
-#define UPB_PARSE_PARAMS \
- upb_Decoder *d, const char *ptr, upb_Message *msg, intptr_t table, \
- uint64_t hasbits, uint64_t data
-
-#define UPB_PARSE_ARGS d, ptr, msg, table, hasbits, data
-
-#define RETURN_GENERIC(m) \
- /* Uncomment either of these for debugging purposes. */ \
- /* fprintf(stderr, m); */ \
- /*__builtin_trap(); */ \
- return fastdecode_generic(d, ptr, msg, table, hasbits, 0);
-
-typedef enum {
- CARD_s = 0, /* Singular (optional, non-repeated) */
- CARD_o = 1, /* Oneof */
- CARD_r = 2, /* Repeated */
- CARD_p = 3 /* Packed Repeated */
-} upb_card;
-
-UPB_NOINLINE
-static const char* fastdecode_isdonefallback(UPB_PARSE_PARAMS) {
- int overrun = data;
- int status;
- ptr = decode_isdonefallback_inl(d, ptr, overrun, &status);
- if (ptr == NULL) {
- return fastdecode_err(d, status);
- }
- data = fastdecode_loadtag(ptr);
- UPB_MUSTTAIL return fastdecode_tagdispatch(UPB_PARSE_ARGS);
-}
-
-UPB_FORCEINLINE
-static const char* fastdecode_dispatch(UPB_PARSE_PARAMS) {
- if (UPB_UNLIKELY(ptr >= d->limit_ptr)) {
- int overrun = ptr - d->end;
- if (UPB_LIKELY(overrun == d->limit)) {
- // Parse is finished.
- *(uint32_t*)msg |= hasbits; // Sync hasbits.
- const upb_MiniTable* l = decode_totablep(table);
- return UPB_UNLIKELY(l->required_count)
- ? decode_checkrequired(d, ptr, msg, l)
- : ptr;
- } else {
- data = overrun;
- UPB_MUSTTAIL return fastdecode_isdonefallback(UPB_PARSE_ARGS);
- }
- }
-
- // Read two bytes of tag data (for a one-byte tag, the high byte is junk).
- data = fastdecode_loadtag(ptr);
- UPB_MUSTTAIL return fastdecode_tagdispatch(UPB_PARSE_ARGS);
-}
-
-UPB_FORCEINLINE
-static bool fastdecode_checktag(uint16_t data, int tagbytes) {
- if (tagbytes == 1) {
- return (data & 0xff) == 0;
- } else {
- return data == 0;
- }
-}
-
-UPB_FORCEINLINE
-static const char* fastdecode_longsize(const char* ptr, int* size) {
- int i;
- UPB_ASSERT(*size & 0x80);
- *size &= 0xff;
- for (i = 0; i < 3; i++) {
- ptr++;
- size_t byte = (uint8_t)ptr[-1];
- *size += (byte - 1) << (7 + 7 * i);
- if (UPB_LIKELY((byte & 0x80) == 0)) return ptr;
- }
- ptr++;
- size_t byte = (uint8_t)ptr[-1];
- // len is limited by 2gb not 4gb, hence 8 and not 16 as normally expected
- // for a 32 bit varint.
- if (UPB_UNLIKELY(byte >= 8)) return NULL;
- *size += (byte - 1) << 28;
- return ptr;
-}
-
-UPB_FORCEINLINE
-static bool fastdecode_boundscheck(const char* ptr, size_t len,
- const char* end) {
- uintptr_t uptr = (uintptr_t)ptr;
- uintptr_t uend = (uintptr_t)end + 16;
- uintptr_t res = uptr + len;
- return res < uptr || res > uend;
-}
-
-UPB_FORCEINLINE
-static bool fastdecode_boundscheck2(const char* ptr, size_t len,
- const char* end) {
- // This is one extra branch compared to the more normal:
- // return (size_t)(end - ptr) < size;
- // However it is one less computation if we are just about to use "ptr + len":
- // https://godbolt.org/z/35YGPz
- // In microbenchmarks this shows an overall 4% improvement.
- uintptr_t uptr = (uintptr_t)ptr;
- uintptr_t uend = (uintptr_t)end;
- uintptr_t res = uptr + len;
- return res < uptr || res > uend;
-}
-
-typedef const char* fastdecode_delimfunc(upb_Decoder* d, const char* ptr,
- void* ctx);
-
-UPB_FORCEINLINE
-static const char* fastdecode_delimited(upb_Decoder* d, const char* ptr,
- fastdecode_delimfunc* func, void* ctx) {
- ptr++;
- int len = (int8_t)ptr[-1];
- if (fastdecode_boundscheck2(ptr, len, d->limit_ptr)) {
- // Slow case: Sub-message is >=128 bytes and/or exceeds the current buffer.
- // If it exceeds the buffer limit, limit/limit_ptr will change during
- // sub-message parsing, so we need to preserve delta, not limit.
- if (UPB_UNLIKELY(len & 0x80)) {
- // Size varint >1 byte (length >= 128).
- ptr = fastdecode_longsize(ptr, &len);
- if (!ptr) {
- // Corrupt wire format: size exceeded INT_MAX.
- return NULL;
- }
- }
- if (ptr - d->end + (int)len > d->limit) {
- // Corrupt wire format: invalid limit.
- return NULL;
- }
- int delta = decode_pushlimit(d, ptr, len);
- ptr = func(d, ptr, ctx);
- decode_poplimit(d, ptr, delta);
- } else {
- // Fast case: Sub-message is <128 bytes and fits in the current buffer.
- // This means we can preserve limit/limit_ptr verbatim.
- const char* saved_limit_ptr = d->limit_ptr;
- int saved_limit = d->limit;
- d->limit_ptr = ptr + len;
- d->limit = d->limit_ptr - d->end;
- UPB_ASSERT(d->limit_ptr == d->end + UPB_MIN(0, d->limit));
- ptr = func(d, ptr, ctx);
- d->limit_ptr = saved_limit_ptr;
- d->limit = saved_limit;
- UPB_ASSERT(d->limit_ptr == d->end + UPB_MIN(0, d->limit));
- }
- return ptr;
-}
-
-/* singular, oneof, repeated field handling ***********************************/
-
-typedef struct {
- upb_Array* arr;
- void* end;
-} fastdecode_arr;
-
-typedef enum {
- FD_NEXT_ATLIMIT,
- FD_NEXT_SAMEFIELD,
- FD_NEXT_OTHERFIELD
-} fastdecode_next;
-
-typedef struct {
- void* dst;
- fastdecode_next next;
- uint32_t tag;
-} fastdecode_nextret;
-
-UPB_FORCEINLINE
-static void* fastdecode_resizearr(upb_Decoder* d, void* dst,
- fastdecode_arr* farr, int valbytes) {
- if (UPB_UNLIKELY(dst == farr->end)) {
- size_t old_size = farr->arr->size;
- size_t old_bytes = old_size * valbytes;
- size_t new_size = old_size * 2;
- size_t new_bytes = new_size * valbytes;
- char* old_ptr = _upb_array_ptr(farr->arr);
- char* new_ptr = upb_Arena_Realloc(&d->arena, old_ptr, old_bytes, new_bytes);
- uint8_t elem_size_lg2 = __builtin_ctz(valbytes);
- farr->arr->size = new_size;
- farr->arr->data = _upb_array_tagptr(new_ptr, elem_size_lg2);
- dst = (void*)(new_ptr + (old_size * valbytes));
- farr->end = (void*)(new_ptr + (new_size * valbytes));
- }
- return dst;
-}
-
-UPB_FORCEINLINE
-static bool fastdecode_tagmatch(uint32_t tag, uint64_t data, int tagbytes) {
- if (tagbytes == 1) {
- return (uint8_t)tag == (uint8_t)data;
- } else {
- return (uint16_t)tag == (uint16_t)data;
- }
-}
-
-UPB_FORCEINLINE
-static void fastdecode_commitarr(void* dst, fastdecode_arr* farr,
- int valbytes) {
- farr->arr->len =
- (size_t)((char*)dst - (char*)_upb_array_ptr(farr->arr)) / valbytes;
-}
-
-UPB_FORCEINLINE
-static fastdecode_nextret fastdecode_nextrepeated(upb_Decoder* d, void* dst,
- const char** ptr,
- fastdecode_arr* farr,
- uint64_t data, int tagbytes,
- int valbytes) {
- fastdecode_nextret ret;
- dst = (char*)dst + valbytes;
-
- if (UPB_LIKELY(!decode_isdone(d, ptr))) {
- ret.tag = fastdecode_loadtag(*ptr);
- if (fastdecode_tagmatch(ret.tag, data, tagbytes)) {
- ret.next = FD_NEXT_SAMEFIELD;
- } else {
- fastdecode_commitarr(dst, farr, valbytes);
- ret.next = FD_NEXT_OTHERFIELD;
- }
- } else {
- fastdecode_commitarr(dst, farr, valbytes);
- ret.next = FD_NEXT_ATLIMIT;
- }
-
- ret.dst = dst;
- return ret;
-}
-
-UPB_FORCEINLINE
-static void* fastdecode_fieldmem(upb_Message* msg, uint64_t data) {
- size_t ofs = data >> 48;
- return (char*)msg + ofs;
-}
-
-UPB_FORCEINLINE
-static void* fastdecode_getfield(upb_Decoder* d, const char* ptr,
- upb_Message* msg, uint64_t* data,
- uint64_t* hasbits, fastdecode_arr* farr,
- int valbytes, upb_card card) {
- switch (card) {
- case CARD_s: {
- uint8_t hasbit_index = *data >> 24;
- // Set hasbit and return pointer to scalar field.
- *hasbits |= 1ull << hasbit_index;
- return fastdecode_fieldmem(msg, *data);
- }
- case CARD_o: {
- uint16_t case_ofs = *data >> 32;
- uint32_t* oneof_case = UPB_PTR_AT(msg, case_ofs, uint32_t);
- uint8_t field_number = *data >> 24;
- *oneof_case = field_number;
- return fastdecode_fieldmem(msg, *data);
- }
- case CARD_r: {
- // Get pointer to upb_Array and allocate/expand if necessary.
- uint8_t elem_size_lg2 = __builtin_ctz(valbytes);
- upb_Array** arr_p = fastdecode_fieldmem(msg, *data);
- char* begin;
- *(uint32_t*)msg |= *hasbits;
- *hasbits = 0;
- if (UPB_LIKELY(!*arr_p)) {
- farr->arr = _upb_Array_New(&d->arena, 8, elem_size_lg2);
- *arr_p = farr->arr;
- } else {
- farr->arr = *arr_p;
- }
- begin = _upb_array_ptr(farr->arr);
- farr->end = begin + (farr->arr->size * valbytes);
- *data = fastdecode_loadtag(ptr);
- return begin + (farr->arr->len * valbytes);
- }
- default:
- UPB_UNREACHABLE();
- }
-}
-
-UPB_FORCEINLINE
-static bool fastdecode_flippacked(uint64_t* data, int tagbytes) {
- *data ^= (0x2 ^ 0x0); // Patch data to match packed wiretype.
- return fastdecode_checktag(*data, tagbytes);
-}
-
-#define FASTDECODE_CHECKPACKED(tagbytes, card, func) \
- if (UPB_UNLIKELY(!fastdecode_checktag(data, tagbytes))) { \
- if (card == CARD_r && fastdecode_flippacked(&data, tagbytes)) { \
- UPB_MUSTTAIL return func(UPB_PARSE_ARGS); \
- } \
- RETURN_GENERIC("packed check tag mismatch\n"); \
- }
-
-/* varint fields **************************************************************/
-
-UPB_FORCEINLINE
-static uint64_t fastdecode_munge(uint64_t val, int valbytes, bool zigzag) {
- if (valbytes == 1) {
- return val != 0;
- } else if (zigzag) {
- if (valbytes == 4) {
- uint32_t n = val;
- return (n >> 1) ^ -(int32_t)(n & 1);
- } else if (valbytes == 8) {
- return (val >> 1) ^ -(int64_t)(val & 1);
- }
- UPB_UNREACHABLE();
- }
- return val;
-}
-
-UPB_FORCEINLINE
-static const char* fastdecode_varint64(const char* ptr, uint64_t* val) {
- ptr++;
- *val = (uint8_t)ptr[-1];
- if (UPB_UNLIKELY(*val & 0x80)) {
- int i;
- for (i = 0; i < 8; i++) {
- ptr++;
- uint64_t byte = (uint8_t)ptr[-1];
- *val += (byte - 1) << (7 + 7 * i);
- if (UPB_LIKELY((byte & 0x80) == 0)) goto done;
- }
- ptr++;
- uint64_t byte = (uint8_t)ptr[-1];
- if (byte > 1) {
- return NULL;
- }
- *val += (byte - 1) << 63;
- }
-done:
- UPB_ASSUME(ptr != NULL);
- return ptr;
-}
-
-#define FASTDECODE_UNPACKEDVARINT(d, ptr, msg, table, hasbits, data, tagbytes, \
- valbytes, card, zigzag, packed) \
- uint64_t val; \
- void* dst; \
- fastdecode_arr farr; \
- \
- FASTDECODE_CHECKPACKED(tagbytes, card, packed); \
- \
- dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &farr, valbytes, \
- card); \
- if (card == CARD_r) { \
- if (UPB_UNLIKELY(!dst)) { \
- RETURN_GENERIC("need array resize\n"); \
- } \
- } \
- \
- again: \
- if (card == CARD_r) { \
- dst = fastdecode_resizearr(d, dst, &farr, valbytes); \
- } \
- \
- ptr += tagbytes; \
- ptr = fastdecode_varint64(ptr, &val); \
- if (ptr == NULL) return fastdecode_err(d, kUpb_DecodeStatus_Malformed); \
- val = fastdecode_munge(val, valbytes, zigzag); \
- memcpy(dst, &val, valbytes); \
- \
- if (card == CARD_r) { \
- fastdecode_nextret ret = fastdecode_nextrepeated( \
- d, dst, &ptr, &farr, data, tagbytes, valbytes); \
- switch (ret.next) { \
- case FD_NEXT_SAMEFIELD: \
- dst = ret.dst; \
- goto again; \
- case FD_NEXT_OTHERFIELD: \
- data = ret.tag; \
- UPB_MUSTTAIL return fastdecode_tagdispatch(UPB_PARSE_ARGS); \
- case FD_NEXT_ATLIMIT: \
- return ptr; \
- } \
- } \
- \
- UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
-
-typedef struct {
- uint8_t valbytes;
- bool zigzag;
- void* dst;
- fastdecode_arr farr;
-} fastdecode_varintdata;
-
-UPB_FORCEINLINE
-static const char* fastdecode_topackedvarint(upb_Decoder* d, const char* ptr,
- void* ctx) {
- fastdecode_varintdata* data = ctx;
- void* dst = data->dst;
- uint64_t val;
-
- while (!decode_isdone(d, &ptr)) {
- dst = fastdecode_resizearr(d, dst, &data->farr, data->valbytes);
- ptr = fastdecode_varint64(ptr, &val);
- if (ptr == NULL) return NULL;
- val = fastdecode_munge(val, data->valbytes, data->zigzag);
- memcpy(dst, &val, data->valbytes);
- dst = (char*)dst + data->valbytes;
- }
-
- fastdecode_commitarr(dst, &data->farr, data->valbytes);
- return ptr;
-}
-
-#define FASTDECODE_PACKEDVARINT(d, ptr, msg, table, hasbits, data, tagbytes, \
- valbytes, zigzag, unpacked) \
- fastdecode_varintdata ctx = {valbytes, zigzag}; \
- \
- FASTDECODE_CHECKPACKED(tagbytes, CARD_r, unpacked); \
- \
- ctx.dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &ctx.farr, \
- valbytes, CARD_r); \
- if (UPB_UNLIKELY(!ctx.dst)) { \
- RETURN_GENERIC("need array resize\n"); \
- } \
- \
- ptr += tagbytes; \
- ptr = fastdecode_delimited(d, ptr, &fastdecode_topackedvarint, &ctx); \
- \
- if (UPB_UNLIKELY(ptr == NULL)) { \
- return fastdecode_err(d, kUpb_DecodeStatus_Malformed); \
- } \
- \
- UPB_MUSTTAIL return fastdecode_dispatch(d, ptr, msg, table, hasbits, 0);
-
-#define FASTDECODE_VARINT(d, ptr, msg, table, hasbits, data, tagbytes, \
- valbytes, card, zigzag, unpacked, packed) \
- if (card == CARD_p) { \
- FASTDECODE_PACKEDVARINT(d, ptr, msg, table, hasbits, data, tagbytes, \
- valbytes, zigzag, unpacked); \
- } else { \
- FASTDECODE_UNPACKEDVARINT(d, ptr, msg, table, hasbits, data, tagbytes, \
- valbytes, card, zigzag, packed); \
- }
-
-#define z_ZZ true
-#define b_ZZ false
-#define v_ZZ false
-
-/* Generate all combinations:
- * {s,o,r,p} x {b1,v4,z4,v8,z8} x {1bt,2bt} */
-
-#define F(card, type, valbytes, tagbytes) \
- UPB_NOINLINE \
- const char* upb_p##card##type##valbytes##_##tagbytes##bt(UPB_PARSE_PARAMS) { \
- FASTDECODE_VARINT(d, ptr, msg, table, hasbits, data, tagbytes, valbytes, \
- CARD_##card, type##_ZZ, \
- upb_pr##type##valbytes##_##tagbytes##bt, \
- upb_pp##type##valbytes##_##tagbytes##bt); \
- }
-
-#define TYPES(card, tagbytes) \
- F(card, b, 1, tagbytes) \
- F(card, v, 4, tagbytes) \
- F(card, v, 8, tagbytes) \
- F(card, z, 4, tagbytes) \
- F(card, z, 8, tagbytes)
-
-#define TAGBYTES(card) \
- TYPES(card, 1) \
- TYPES(card, 2)
-
-TAGBYTES(s)
-TAGBYTES(o)
-TAGBYTES(r)
-TAGBYTES(p)
-
-#undef z_ZZ
-#undef b_ZZ
-#undef v_ZZ
-#undef o_ONEOF
-#undef s_ONEOF
-#undef r_ONEOF
-#undef F
-#undef TYPES
-#undef TAGBYTES
-#undef FASTDECODE_UNPACKEDVARINT
-#undef FASTDECODE_PACKEDVARINT
-#undef FASTDECODE_VARINT
-
-/* fixed fields ***************************************************************/
-
-#define FASTDECODE_UNPACKEDFIXED(d, ptr, msg, table, hasbits, data, tagbytes, \
- valbytes, card, packed) \
- void* dst; \
- fastdecode_arr farr; \
- \
- FASTDECODE_CHECKPACKED(tagbytes, card, packed) \
- \
- dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &farr, valbytes, \
- card); \
- if (card == CARD_r) { \
- if (UPB_UNLIKELY(!dst)) { \
- RETURN_GENERIC("couldn't allocate array in arena\n"); \
- } \
- } \
- \
- again: \
- if (card == CARD_r) { \
- dst = fastdecode_resizearr(d, dst, &farr, valbytes); \
- } \
- \
- ptr += tagbytes; \
- memcpy(dst, ptr, valbytes); \
- ptr += valbytes; \
- \
- if (card == CARD_r) { \
- fastdecode_nextret ret = fastdecode_nextrepeated( \
- d, dst, &ptr, &farr, data, tagbytes, valbytes); \
- switch (ret.next) { \
- case FD_NEXT_SAMEFIELD: \
- dst = ret.dst; \
- goto again; \
- case FD_NEXT_OTHERFIELD: \
- data = ret.tag; \
- UPB_MUSTTAIL return fastdecode_tagdispatch(UPB_PARSE_ARGS); \
- case FD_NEXT_ATLIMIT: \
- return ptr; \
- } \
- } \
- \
- UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
-
-#define FASTDECODE_PACKEDFIXED(d, ptr, msg, table, hasbits, data, tagbytes, \
- valbytes, unpacked) \
- FASTDECODE_CHECKPACKED(tagbytes, CARD_r, unpacked) \
- \
- ptr += tagbytes; \
- int size = (uint8_t)ptr[0]; \
- ptr++; \
- if (size & 0x80) { \
- ptr = fastdecode_longsize(ptr, &size); \
- } \
- \
- if (UPB_UNLIKELY(fastdecode_boundscheck(ptr, size, d->limit_ptr) || \
- (size % valbytes) != 0)) { \
- return fastdecode_err(d, kUpb_DecodeStatus_Malformed); \
- } \
- \
- upb_Array** arr_p = fastdecode_fieldmem(msg, data); \
- upb_Array* arr = *arr_p; \
- uint8_t elem_size_lg2 = __builtin_ctz(valbytes); \
- int elems = size / valbytes; \
- \
- if (UPB_LIKELY(!arr)) { \
- *arr_p = arr = _upb_Array_New(&d->arena, elems, elem_size_lg2); \
- if (!arr) { \
- return fastdecode_err(d, kUpb_DecodeStatus_Malformed); \
- } \
- } else { \
- _upb_Array_Resize(arr, elems, &d->arena); \
- } \
- \
- char* dst = _upb_array_ptr(arr); \
- memcpy(dst, ptr, size); \
- arr->len = elems; \
- \
- ptr += size; \
- UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
-
-#define FASTDECODE_FIXED(d, ptr, msg, table, hasbits, data, tagbytes, \
- valbytes, card, unpacked, packed) \
- if (card == CARD_p) { \
- FASTDECODE_PACKEDFIXED(d, ptr, msg, table, hasbits, data, tagbytes, \
- valbytes, unpacked); \
- } else { \
- FASTDECODE_UNPACKEDFIXED(d, ptr, msg, table, hasbits, data, tagbytes, \
- valbytes, card, packed); \
- }
-
-/* Generate all combinations:
- * {s,o,r,p} x {f4,f8} x {1bt,2bt} */
-
-#define F(card, valbytes, tagbytes) \
- UPB_NOINLINE \
- const char* upb_p##card##f##valbytes##_##tagbytes##bt(UPB_PARSE_PARAMS) { \
- FASTDECODE_FIXED(d, ptr, msg, table, hasbits, data, tagbytes, valbytes, \
- CARD_##card, upb_ppf##valbytes##_##tagbytes##bt, \
- upb_prf##valbytes##_##tagbytes##bt); \
- }
-
-#define TYPES(card, tagbytes) \
- F(card, 4, tagbytes) \
- F(card, 8, tagbytes)
-
-#define TAGBYTES(card) \
- TYPES(card, 1) \
- TYPES(card, 2)
-
-TAGBYTES(s)
-TAGBYTES(o)
-TAGBYTES(r)
-TAGBYTES(p)
-
-#undef F
-#undef TYPES
-#undef TAGBYTES
-#undef FASTDECODE_UNPACKEDFIXED
-#undef FASTDECODE_PACKEDFIXED
-
-/* string fields **************************************************************/
-
-typedef const char* fastdecode_copystr_func(struct upb_Decoder* d,
- const char* ptr, upb_Message* msg,
- const upb_MiniTable* table,
- uint64_t hasbits,
- upb_StringView* dst);
-
-UPB_NOINLINE
-static const char* fastdecode_verifyutf8(upb_Decoder* d, const char* ptr,
- upb_Message* msg, intptr_t table,
- uint64_t hasbits, uint64_t data) {
- upb_StringView* dst = (upb_StringView*)data;
- if (!decode_verifyutf8_inl(dst->data, dst->size)) {
- return fastdecode_err(d, kUpb_DecodeStatus_BadUtf8);
- }
- UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
-}
-
-#define FASTDECODE_LONGSTRING(d, ptr, msg, table, hasbits, dst, validate_utf8) \
- int size = (uint8_t)ptr[0]; /* Could plumb through hasbits. */ \
- ptr++; \
- if (size & 0x80) { \
- ptr = fastdecode_longsize(ptr, &size); \
- } \
- \
- if (UPB_UNLIKELY(fastdecode_boundscheck(ptr, size, d->limit_ptr))) { \
- dst->size = 0; \
- return fastdecode_err(d, kUpb_DecodeStatus_Malformed); \
- } \
- \
- if (d->options & kUpb_DecodeOption_AliasString) { \
- dst->data = ptr; \
- dst->size = size; \
- } else { \
- char* data = upb_Arena_Malloc(&d->arena, size); \
- if (!data) { \
- return fastdecode_err(d, kUpb_DecodeStatus_OutOfMemory); \
- } \
- memcpy(data, ptr, size); \
- dst->data = data; \
- dst->size = size; \
- } \
- \
- ptr += size; \
- if (validate_utf8) { \
- data = (uint64_t)dst; \
- UPB_MUSTTAIL return fastdecode_verifyutf8(UPB_PARSE_ARGS); \
- } else { \
- UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS); \
- }
-
-UPB_NOINLINE
-static const char* fastdecode_longstring_utf8(struct upb_Decoder* d,
- const char* ptr, upb_Message* msg,
- intptr_t table, uint64_t hasbits,
- uint64_t data) {
- upb_StringView* dst = (upb_StringView*)data;
- FASTDECODE_LONGSTRING(d, ptr, msg, table, hasbits, dst, true);
-}
-
-UPB_NOINLINE
-static const char* fastdecode_longstring_noutf8(
- struct upb_Decoder* d, const char* ptr, upb_Message* msg, intptr_t table,
- uint64_t hasbits, uint64_t data) {
- upb_StringView* dst = (upb_StringView*)data;
- FASTDECODE_LONGSTRING(d, ptr, msg, table, hasbits, dst, false);
-}
-
-UPB_FORCEINLINE
-static void fastdecode_docopy(upb_Decoder* d, const char* ptr, uint32_t size,
- int copy, char* data, upb_StringView* dst) {
- d->arena.head.ptr += copy;
- dst->data = data;
- UPB_UNPOISON_MEMORY_REGION(data, copy);
- memcpy(data, ptr, copy);
- UPB_POISON_MEMORY_REGION(data + size, copy - size);
-}
-
-#define FASTDECODE_COPYSTRING(d, ptr, msg, table, hasbits, data, tagbytes, \
- card, validate_utf8) \
- upb_StringView* dst; \
- fastdecode_arr farr; \
- int64_t size; \
- size_t arena_has; \
- size_t common_has; \
- char* buf; \
- \
- UPB_ASSERT((d->options & kUpb_DecodeOption_AliasString) == 0); \
- UPB_ASSERT(fastdecode_checktag(data, tagbytes)); \
- \
- dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &farr, \
- sizeof(upb_StringView), card); \
- \
- again: \
- if (card == CARD_r) { \
- dst = fastdecode_resizearr(d, dst, &farr, sizeof(upb_StringView)); \
- } \
- \
- size = (uint8_t)ptr[tagbytes]; \
- ptr += tagbytes + 1; \
- dst->size = size; \
- \
- buf = d->arena.head.ptr; \
- arena_has = _upb_ArenaHas(&d->arena); \
- common_has = UPB_MIN(arena_has, (d->end - ptr) + 16); \
- \
- if (UPB_LIKELY(size <= 15 - tagbytes)) { \
- if (arena_has < 16) goto longstr; \
- d->arena.head.ptr += 16; \
- memcpy(buf, ptr - tagbytes - 1, 16); \
- dst->data = buf + tagbytes + 1; \
- } else if (UPB_LIKELY(size <= 32)) { \
- if (UPB_UNLIKELY(common_has < 32)) goto longstr; \
- fastdecode_docopy(d, ptr, size, 32, buf, dst); \
- } else if (UPB_LIKELY(size <= 64)) { \
- if (UPB_UNLIKELY(common_has < 64)) goto longstr; \
- fastdecode_docopy(d, ptr, size, 64, buf, dst); \
- } else if (UPB_LIKELY(size < 128)) { \
- if (UPB_UNLIKELY(common_has < 128)) goto longstr; \
- fastdecode_docopy(d, ptr, size, 128, buf, dst); \
- } else { \
- goto longstr; \
- } \
- \
- ptr += size; \
- \
- if (card == CARD_r) { \
- if (validate_utf8 && !decode_verifyutf8_inl(dst->data, dst->size)) { \
- return fastdecode_err(d, kUpb_DecodeStatus_BadUtf8); \
- } \
- fastdecode_nextret ret = fastdecode_nextrepeated( \
- d, dst, &ptr, &farr, data, tagbytes, sizeof(upb_StringView)); \
- switch (ret.next) { \
- case FD_NEXT_SAMEFIELD: \
- dst = ret.dst; \
- goto again; \
- case FD_NEXT_OTHERFIELD: \
- data = ret.tag; \
- UPB_MUSTTAIL return fastdecode_tagdispatch(UPB_PARSE_ARGS); \
- case FD_NEXT_ATLIMIT: \
- return ptr; \
- } \
- } \
- \
- if (card != CARD_r && validate_utf8) { \
- data = (uint64_t)dst; \
- UPB_MUSTTAIL return fastdecode_verifyutf8(UPB_PARSE_ARGS); \
- } \
- \
- UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS); \
- \
- longstr: \
- if (card == CARD_r) { \
- fastdecode_commitarr(dst + 1, &farr, sizeof(upb_StringView)); \
- } \
- ptr--; \
- if (validate_utf8) { \
- UPB_MUSTTAIL return fastdecode_longstring_utf8(d, ptr, msg, table, \
- hasbits, (uint64_t)dst); \
- } else { \
- UPB_MUSTTAIL return fastdecode_longstring_noutf8(d, ptr, msg, table, \
- hasbits, (uint64_t)dst); \
- }
-
-#define FASTDECODE_STRING(d, ptr, msg, table, hasbits, data, tagbytes, card, \
- copyfunc, validate_utf8) \
- upb_StringView* dst; \
- fastdecode_arr farr; \
- int64_t size; \
- \
- if (UPB_UNLIKELY(!fastdecode_checktag(data, tagbytes))) { \
- RETURN_GENERIC("string field tag mismatch\n"); \
- } \
- \
- if (UPB_UNLIKELY((d->options & kUpb_DecodeOption_AliasString) == 0)) { \
- UPB_MUSTTAIL return copyfunc(UPB_PARSE_ARGS); \
- } \
- \
- dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &farr, \
- sizeof(upb_StringView), card); \
- \
- again: \
- if (card == CARD_r) { \
- dst = fastdecode_resizearr(d, dst, &farr, sizeof(upb_StringView)); \
- } \
- \
- size = (int8_t)ptr[tagbytes]; \
- ptr += tagbytes + 1; \
- dst->data = ptr; \
- dst->size = size; \
- \
- if (UPB_UNLIKELY(fastdecode_boundscheck(ptr, size, d->end))) { \
- ptr--; \
- if (validate_utf8) { \
- return fastdecode_longstring_utf8(d, ptr, msg, table, hasbits, \
- (uint64_t)dst); \
- } else { \
- return fastdecode_longstring_noutf8(d, ptr, msg, table, hasbits, \
- (uint64_t)dst); \
- } \
- } \
- \
- ptr += size; \
- \
- if (card == CARD_r) { \
- if (validate_utf8 && !decode_verifyutf8_inl(dst->data, dst->size)) { \
- return fastdecode_err(d, kUpb_DecodeStatus_BadUtf8); \
- } \
- fastdecode_nextret ret = fastdecode_nextrepeated( \
- d, dst, &ptr, &farr, data, tagbytes, sizeof(upb_StringView)); \
- switch (ret.next) { \
- case FD_NEXT_SAMEFIELD: \
- dst = ret.dst; \
- if (UPB_UNLIKELY((d->options & kUpb_DecodeOption_AliasString) == 0)) { \
- /* Buffer flipped and we can't alias any more. Bounce to */ \
- /* copyfunc(), but via dispatch since we need to reload table */ \
- /* data also. */ \
- fastdecode_commitarr(dst, &farr, sizeof(upb_StringView)); \
- data = ret.tag; \
- UPB_MUSTTAIL return fastdecode_tagdispatch(UPB_PARSE_ARGS); \
- } \
- goto again; \
- case FD_NEXT_OTHERFIELD: \
- data = ret.tag; \
- UPB_MUSTTAIL return fastdecode_tagdispatch(UPB_PARSE_ARGS); \
- case FD_NEXT_ATLIMIT: \
- return ptr; \
- } \
- } \
- \
- if (card != CARD_r && validate_utf8) { \
- data = (uint64_t)dst; \
- UPB_MUSTTAIL return fastdecode_verifyutf8(UPB_PARSE_ARGS); \
- } \
- \
- UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
-
-/* Generate all combinations:
- * {p,c} x {s,o,r} x {s, b} x {1bt,2bt} */
-
-#define s_VALIDATE true
-#define b_VALIDATE false
-
-#define F(card, tagbytes, type) \
- UPB_NOINLINE \
- const char* upb_c##card##type##_##tagbytes##bt(UPB_PARSE_PARAMS) { \
- FASTDECODE_COPYSTRING(d, ptr, msg, table, hasbits, data, tagbytes, \
- CARD_##card, type##_VALIDATE); \
- } \
- const char* upb_p##card##type##_##tagbytes##bt(UPB_PARSE_PARAMS) { \
- FASTDECODE_STRING(d, ptr, msg, table, hasbits, data, tagbytes, \
- CARD_##card, upb_c##card##type##_##tagbytes##bt, \
- type##_VALIDATE); \
- }
-
-#define UTF8(card, tagbytes) \
- F(card, tagbytes, s) \
- F(card, tagbytes, b)
-
-#define TAGBYTES(card) \
- UTF8(card, 1) \
- UTF8(card, 2)
-
-TAGBYTES(s)
-TAGBYTES(o)
-TAGBYTES(r)
-
-#undef s_VALIDATE
-#undef b_VALIDATE
-#undef F
-#undef TAGBYTES
-#undef FASTDECODE_LONGSTRING
-#undef FASTDECODE_COPYSTRING
-#undef FASTDECODE_STRING
-
-/* message fields *************************************************************/
-
-UPB_INLINE
-upb_Message* decode_newmsg_ceil(upb_Decoder* d, const upb_MiniTable* l,
- int msg_ceil_bytes) {
- size_t size = l->size + sizeof(upb_Message_Internal);
- char* msg_data;
- if (UPB_LIKELY(msg_ceil_bytes > 0 &&
- _upb_ArenaHas(&d->arena) >= msg_ceil_bytes)) {
- UPB_ASSERT(size <= (size_t)msg_ceil_bytes);
- msg_data = d->arena.head.ptr;
- d->arena.head.ptr += size;
- UPB_UNPOISON_MEMORY_REGION(msg_data, msg_ceil_bytes);
- memset(msg_data, 0, msg_ceil_bytes);
- UPB_POISON_MEMORY_REGION(msg_data + size, msg_ceil_bytes - size);
- } else {
- msg_data = (char*)upb_Arena_Malloc(&d->arena, size);
- memset(msg_data, 0, size);
- }
- return msg_data + sizeof(upb_Message_Internal);
-}
-
-typedef struct {
- intptr_t table;
- upb_Message* msg;
-} fastdecode_submsgdata;
-
-UPB_FORCEINLINE
-static const char* fastdecode_tosubmsg(upb_Decoder* d, const char* ptr,
- void* ctx) {
- fastdecode_submsgdata* submsg = ctx;
- ptr = fastdecode_dispatch(d, ptr, submsg->msg, submsg->table, 0, 0);
- UPB_ASSUME(ptr != NULL);
- return ptr;
-}
-
-#define FASTDECODE_SUBMSG(d, ptr, msg, table, hasbits, data, tagbytes, \
- msg_ceil_bytes, card) \
- \
- if (UPB_UNLIKELY(!fastdecode_checktag(data, tagbytes))) { \
- RETURN_GENERIC("submessage field tag mismatch\n"); \
- } \
- \
- if (--d->depth == 0) { \
- return fastdecode_err(d, kUpb_DecodeStatus_MaxDepthExceeded); \
- } \
- \
- upb_Message** dst; \
- uint32_t submsg_idx = (data >> 16) & 0xff; \
- const upb_MiniTable* tablep = decode_totablep(table); \
- const upb_MiniTable* subtablep = tablep->subs[submsg_idx].submsg; \
- fastdecode_submsgdata submsg = {decode_totable(subtablep)}; \
- fastdecode_arr farr; \
- \
- if (subtablep->table_mask == (uint8_t)-1) { \
- RETURN_GENERIC("submessage doesn't have fast tables."); \
- } \
- \
- dst = fastdecode_getfield(d, ptr, msg, &data, &hasbits, &farr, \
- sizeof(upb_Message*), card); \
- \
- if (card == CARD_s) { \
- *(uint32_t*)msg |= hasbits; \
- hasbits = 0; \
- } \
- \
- again: \
- if (card == CARD_r) { \
- dst = fastdecode_resizearr(d, dst, &farr, sizeof(upb_Message*)); \
- } \
- \
- submsg.msg = *dst; \
- \
- if (card == CARD_r || UPB_LIKELY(!submsg.msg)) { \
- *dst = submsg.msg = decode_newmsg_ceil(d, subtablep, msg_ceil_bytes); \
- } \
- \
- ptr += tagbytes; \
- ptr = fastdecode_delimited(d, ptr, fastdecode_tosubmsg, &submsg); \
- \
- if (UPB_UNLIKELY(ptr == NULL || d->end_group != DECODE_NOGROUP)) { \
- return fastdecode_err(d, kUpb_DecodeStatus_Malformed); \
- } \
- \
- if (card == CARD_r) { \
- fastdecode_nextret ret = fastdecode_nextrepeated( \
- d, dst, &ptr, &farr, data, tagbytes, sizeof(upb_Message*)); \
- switch (ret.next) { \
- case FD_NEXT_SAMEFIELD: \
- dst = ret.dst; \
- goto again; \
- case FD_NEXT_OTHERFIELD: \
- d->depth++; \
- data = ret.tag; \
- UPB_MUSTTAIL return fastdecode_tagdispatch(UPB_PARSE_ARGS); \
- case FD_NEXT_ATLIMIT: \
- d->depth++; \
- return ptr; \
- } \
- } \
- \
- d->depth++; \
- UPB_MUSTTAIL return fastdecode_dispatch(UPB_PARSE_ARGS);
-
-#define F(card, tagbytes, size_ceil, ceil_arg) \
- const char* upb_p##card##m_##tagbytes##bt_max##size_ceil##b( \
- UPB_PARSE_PARAMS) { \
- FASTDECODE_SUBMSG(d, ptr, msg, table, hasbits, data, tagbytes, ceil_arg, \
- CARD_##card); \
- }
-
-#define SIZES(card, tagbytes) \
- F(card, tagbytes, 64, 64) \
- F(card, tagbytes, 128, 128) \
- F(card, tagbytes, 192, 192) \
- F(card, tagbytes, 256, 256) \
- F(card, tagbytes, max, -1)
-
-#define TAGBYTES(card) \
- SIZES(card, 1) \
- SIZES(card, 2)
-
-TAGBYTES(s)
-TAGBYTES(o)
-TAGBYTES(r)
-
-#undef TAGBYTES
-#undef SIZES
-#undef F
-#undef FASTDECODE_SUBMSG
-
-#endif /* UPB_FASTTABLE */
-
-/** bazel-out/k8-fastbuild/bin/external/com_google_protobuf/google/protobuf/descriptor.upb.c ************************************************************//* This file was generated by upbc (the upb compiler) from the input
- * file:
- *
- * google/protobuf/descriptor.proto
- *
- * Do not edit -- your changes will be discarded when the file is
- * regenerated. */
-
-#include <stddef.h>
-
-
-static const upb_MiniTable_Sub google_protobuf_FileDescriptorSet_submsgs[1] = {
- {.submsg = &google_protobuf_FileDescriptorProto_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_FileDescriptorSet__fields[1] = {
- {1, UPB_SIZE(0, 0), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_FileDescriptorSet_msginit = {
- &google_protobuf_FileDescriptorSet_submsgs[0],
- &google_protobuf_FileDescriptorSet__fields[0],
- UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_FileDescriptorProto_submsgs[6] = {
- {.submsg = &google_protobuf_DescriptorProto_msginit},
- {.submsg = &google_protobuf_EnumDescriptorProto_msginit},
- {.submsg = &google_protobuf_FieldDescriptorProto_msginit},
- {.submsg = &google_protobuf_FileOptions_msginit},
- {.submsg = &google_protobuf_ServiceDescriptorProto_msginit},
- {.submsg = &google_protobuf_SourceCodeInfo_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_FileDescriptorProto__fields[12] = {
- {1, UPB_SIZE(4, 8), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(12, 24), 2, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(36, 72), 0, 0, 12, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {4, UPB_SIZE(40, 80), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {5, UPB_SIZE(44, 88), 0, 1, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {6, UPB_SIZE(48, 96), 0, 4, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {7, UPB_SIZE(52, 104), 0, 2, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {8, UPB_SIZE(28, 56), 3, 3, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {9, UPB_SIZE(32, 64), 4, 5, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {10, UPB_SIZE(56, 112), 0, 0, 5, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {11, UPB_SIZE(60, 120), 0, 0, 5, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {12, UPB_SIZE(20, 40), 5, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_FileDescriptorProto_msginit = {
- &google_protobuf_FileDescriptorProto_submsgs[0],
- &google_protobuf_FileDescriptorProto__fields[0],
- UPB_SIZE(64, 128), 12, kUpb_ExtMode_NonExtendable, 12, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_DescriptorProto_submsgs[7] = {
- {.submsg = &google_protobuf_DescriptorProto_msginit},
- {.submsg = &google_protobuf_DescriptorProto_ExtensionRange_msginit},
- {.submsg = &google_protobuf_DescriptorProto_ReservedRange_msginit},
- {.submsg = &google_protobuf_EnumDescriptorProto_msginit},
- {.submsg = &google_protobuf_FieldDescriptorProto_msginit},
- {.submsg = &google_protobuf_MessageOptions_msginit},
- {.submsg = &google_protobuf_OneofDescriptorProto_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_DescriptorProto__fields[10] = {
- {1, UPB_SIZE(4, 8), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(16, 32), 0, 4, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(20, 40), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {4, UPB_SIZE(24, 48), 0, 3, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {5, UPB_SIZE(28, 56), 0, 1, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {6, UPB_SIZE(32, 64), 0, 4, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {7, UPB_SIZE(12, 24), 2, 5, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {8, UPB_SIZE(36, 72), 0, 6, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {9, UPB_SIZE(40, 80), 0, 2, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {10, UPB_SIZE(44, 88), 0, 0, 12, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_DescriptorProto_msginit = {
- &google_protobuf_DescriptorProto_submsgs[0],
- &google_protobuf_DescriptorProto__fields[0],
- UPB_SIZE(48, 96), 10, kUpb_ExtMode_NonExtendable, 10, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_DescriptorProto_ExtensionRange_submsgs[1] = {
- {.submsg = &google_protobuf_ExtensionRangeOptions_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_DescriptorProto_ExtensionRange__fields[3] = {
- {1, UPB_SIZE(4, 4), 1, 0, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(8, 8), 2, 0, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(12, 16), 3, 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_DescriptorProto_ExtensionRange_msginit = {
- &google_protobuf_DescriptorProto_ExtensionRange_submsgs[0],
- &google_protobuf_DescriptorProto_ExtensionRange__fields[0],
- UPB_SIZE(16, 24), 3, kUpb_ExtMode_NonExtendable, 3, 255, 0,
-};
-
-static const upb_MiniTable_Field google_protobuf_DescriptorProto_ReservedRange__fields[2] = {
- {1, UPB_SIZE(4, 4), 1, 0, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(8, 8), 2, 0, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_DescriptorProto_ReservedRange_msginit = {
- NULL,
- &google_protobuf_DescriptorProto_ReservedRange__fields[0],
- UPB_SIZE(16, 16), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_ExtensionRangeOptions_submsgs[1] = {
- {.submsg = &google_protobuf_UninterpretedOption_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_ExtensionRangeOptions__fields[1] = {
- {999, UPB_SIZE(0, 0), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_ExtensionRangeOptions_msginit = {
- &google_protobuf_ExtensionRangeOptions_submsgs[0],
- &google_protobuf_ExtensionRangeOptions__fields[0],
- UPB_SIZE(8, 8), 1, kUpb_ExtMode_Extendable, 0, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_FieldDescriptorProto_submsgs[3] = {
- {.submsg = &google_protobuf_FieldOptions_msginit},
- {.subenum = &google_protobuf_FieldDescriptorProto_Label_enuminit},
- {.subenum = &google_protobuf_FieldDescriptorProto_Type_enuminit},
-};
-
-static const upb_MiniTable_Field google_protobuf_FieldDescriptorProto__fields[11] = {
- {1, UPB_SIZE(24, 24), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(32, 40), 2, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(12, 12), 3, 0, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {4, UPB_SIZE(4, 4), 4, 1, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {5, UPB_SIZE(8, 8), 5, 2, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {6, UPB_SIZE(40, 56), 6, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {7, UPB_SIZE(48, 72), 7, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {8, UPB_SIZE(64, 104), 8, 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {9, UPB_SIZE(16, 16), 9, 0, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {10, UPB_SIZE(56, 88), 10, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {17, UPB_SIZE(20, 20), 11, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_FieldDescriptorProto_msginit = {
- &google_protobuf_FieldDescriptorProto_submsgs[0],
- &google_protobuf_FieldDescriptorProto__fields[0],
- UPB_SIZE(72, 112), 11, kUpb_ExtMode_NonExtendable, 10, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_OneofDescriptorProto_submsgs[1] = {
- {.submsg = &google_protobuf_OneofOptions_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_OneofDescriptorProto__fields[2] = {
- {1, UPB_SIZE(4, 8), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(12, 24), 2, 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_OneofDescriptorProto_msginit = {
- &google_protobuf_OneofDescriptorProto_submsgs[0],
- &google_protobuf_OneofDescriptorProto__fields[0],
- UPB_SIZE(16, 32), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_EnumDescriptorProto_submsgs[3] = {
- {.submsg = &google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit},
- {.submsg = &google_protobuf_EnumOptions_msginit},
- {.submsg = &google_protobuf_EnumValueDescriptorProto_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_EnumDescriptorProto__fields[5] = {
- {1, UPB_SIZE(4, 8), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(16, 32), 0, 2, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(12, 24), 2, 1, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {4, UPB_SIZE(20, 40), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {5, UPB_SIZE(24, 48), 0, 0, 12, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_EnumDescriptorProto_msginit = {
- &google_protobuf_EnumDescriptorProto_submsgs[0],
- &google_protobuf_EnumDescriptorProto__fields[0],
- UPB_SIZE(32, 64), 5, kUpb_ExtMode_NonExtendable, 5, 255, 0,
-};
-
-static const upb_MiniTable_Field google_protobuf_EnumDescriptorProto_EnumReservedRange__fields[2] = {
- {1, UPB_SIZE(4, 4), 1, 0, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(8, 8), 2, 0, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit = {
- NULL,
- &google_protobuf_EnumDescriptorProto_EnumReservedRange__fields[0],
- UPB_SIZE(16, 16), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_EnumValueDescriptorProto_submsgs[1] = {
- {.submsg = &google_protobuf_EnumValueOptions_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_EnumValueDescriptorProto__fields[3] = {
- {1, UPB_SIZE(8, 8), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(4, 4), 2, 0, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(16, 24), 3, 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_EnumValueDescriptorProto_msginit = {
- &google_protobuf_EnumValueDescriptorProto_submsgs[0],
- &google_protobuf_EnumValueDescriptorProto__fields[0],
- UPB_SIZE(24, 32), 3, kUpb_ExtMode_NonExtendable, 3, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_ServiceDescriptorProto_submsgs[2] = {
- {.submsg = &google_protobuf_MethodDescriptorProto_msginit},
- {.submsg = &google_protobuf_ServiceOptions_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_ServiceDescriptorProto__fields[3] = {
- {1, UPB_SIZE(4, 8), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(16, 32), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(12, 24), 2, 1, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_ServiceDescriptorProto_msginit = {
- &google_protobuf_ServiceDescriptorProto_submsgs[0],
- &google_protobuf_ServiceDescriptorProto__fields[0],
- UPB_SIZE(24, 48), 3, kUpb_ExtMode_NonExtendable, 3, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_MethodDescriptorProto_submsgs[1] = {
- {.submsg = &google_protobuf_MethodOptions_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_MethodDescriptorProto__fields[6] = {
- {1, UPB_SIZE(4, 8), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(12, 24), 2, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(20, 40), 3, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {4, UPB_SIZE(28, 56), 4, 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {5, UPB_SIZE(1, 1), 5, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {6, UPB_SIZE(2, 2), 6, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_MethodDescriptorProto_msginit = {
- &google_protobuf_MethodDescriptorProto_submsgs[0],
- &google_protobuf_MethodDescriptorProto__fields[0],
- UPB_SIZE(32, 64), 6, kUpb_ExtMode_NonExtendable, 6, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_FileOptions_submsgs[2] = {
- {.submsg = &google_protobuf_UninterpretedOption_msginit},
- {.subenum = &google_protobuf_FileOptions_OptimizeMode_enuminit},
-};
-
-static const upb_MiniTable_Field google_protobuf_FileOptions__fields[21] = {
- {1, UPB_SIZE(20, 24), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {8, UPB_SIZE(28, 40), 2, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {9, UPB_SIZE(4, 4), 3, 1, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {10, UPB_SIZE(8, 8), 4, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {11, UPB_SIZE(36, 56), 5, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {16, UPB_SIZE(9, 9), 6, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {17, UPB_SIZE(10, 10), 7, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {18, UPB_SIZE(11, 11), 8, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {20, UPB_SIZE(12, 12), 9, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {23, UPB_SIZE(13, 13), 10, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {27, UPB_SIZE(14, 14), 11, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {31, UPB_SIZE(15, 15), 12, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {36, UPB_SIZE(44, 72), 13, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {37, UPB_SIZE(52, 88), 14, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {39, UPB_SIZE(60, 104), 15, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {40, UPB_SIZE(68, 120), 16, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {41, UPB_SIZE(76, 136), 17, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {42, UPB_SIZE(16, 16), 18, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {44, UPB_SIZE(84, 152), 19, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {45, UPB_SIZE(92, 168), 20, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {999, UPB_SIZE(100, 184), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_FileOptions_msginit = {
- &google_protobuf_FileOptions_submsgs[0],
- &google_protobuf_FileOptions__fields[0],
- UPB_SIZE(104, 192), 21, kUpb_ExtMode_Extendable, 1, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_MessageOptions_submsgs[1] = {
- {.submsg = &google_protobuf_UninterpretedOption_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_MessageOptions__fields[5] = {
- {1, UPB_SIZE(1, 1), 1, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(2, 2), 2, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(3, 3), 3, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {7, UPB_SIZE(4, 4), 4, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {999, UPB_SIZE(8, 8), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_MessageOptions_msginit = {
- &google_protobuf_MessageOptions_submsgs[0],
- &google_protobuf_MessageOptions__fields[0],
- UPB_SIZE(16, 16), 5, kUpb_ExtMode_Extendable, 3, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_FieldOptions_submsgs[3] = {
- {.submsg = &google_protobuf_UninterpretedOption_msginit},
- {.subenum = &google_protobuf_FieldOptions_CType_enuminit},
- {.subenum = &google_protobuf_FieldOptions_JSType_enuminit},
-};
-
-static const upb_MiniTable_Field google_protobuf_FieldOptions__fields[8] = {
- {1, UPB_SIZE(4, 4), 1, 1, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(12, 12), 2, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(13, 13), 3, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {5, UPB_SIZE(14, 14), 4, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {6, UPB_SIZE(8, 8), 5, 2, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {10, UPB_SIZE(15, 15), 6, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {15, UPB_SIZE(16, 16), 7, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {999, UPB_SIZE(20, 24), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_FieldOptions_msginit = {
- &google_protobuf_FieldOptions_submsgs[0],
- &google_protobuf_FieldOptions__fields[0],
- UPB_SIZE(24, 32), 8, kUpb_ExtMode_Extendable, 3, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_OneofOptions_submsgs[1] = {
- {.submsg = &google_protobuf_UninterpretedOption_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_OneofOptions__fields[1] = {
- {999, UPB_SIZE(0, 0), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_OneofOptions_msginit = {
- &google_protobuf_OneofOptions_submsgs[0],
- &google_protobuf_OneofOptions__fields[0],
- UPB_SIZE(8, 8), 1, kUpb_ExtMode_Extendable, 0, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_EnumOptions_submsgs[1] = {
- {.submsg = &google_protobuf_UninterpretedOption_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_EnumOptions__fields[3] = {
- {2, UPB_SIZE(1, 1), 1, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(2, 2), 2, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {999, UPB_SIZE(4, 8), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_EnumOptions_msginit = {
- &google_protobuf_EnumOptions_submsgs[0],
- &google_protobuf_EnumOptions__fields[0],
- UPB_SIZE(8, 16), 3, kUpb_ExtMode_Extendable, 0, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_EnumValueOptions_submsgs[1] = {
- {.submsg = &google_protobuf_UninterpretedOption_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_EnumValueOptions__fields[2] = {
- {1, UPB_SIZE(1, 1), 1, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {999, UPB_SIZE(4, 8), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_EnumValueOptions_msginit = {
- &google_protobuf_EnumValueOptions_submsgs[0],
- &google_protobuf_EnumValueOptions__fields[0],
- UPB_SIZE(8, 16), 2, kUpb_ExtMode_Extendable, 1, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_ServiceOptions_submsgs[1] = {
- {.submsg = &google_protobuf_UninterpretedOption_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_ServiceOptions__fields[2] = {
- {33, UPB_SIZE(1, 1), 1, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {999, UPB_SIZE(4, 8), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_ServiceOptions_msginit = {
- &google_protobuf_ServiceOptions_submsgs[0],
- &google_protobuf_ServiceOptions__fields[0],
- UPB_SIZE(8, 16), 2, kUpb_ExtMode_Extendable, 0, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_MethodOptions_submsgs[2] = {
- {.submsg = &google_protobuf_UninterpretedOption_msginit},
- {.subenum = &google_protobuf_MethodOptions_IdempotencyLevel_enuminit},
-};
-
-static const upb_MiniTable_Field google_protobuf_MethodOptions__fields[3] = {
- {33, UPB_SIZE(8, 8), 1, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
- {34, UPB_SIZE(4, 4), 2, 1, 14, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {999, UPB_SIZE(12, 16), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_MethodOptions_msginit = {
- &google_protobuf_MethodOptions_submsgs[0],
- &google_protobuf_MethodOptions__fields[0],
- UPB_SIZE(16, 24), 3, kUpb_ExtMode_Extendable, 0, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_UninterpretedOption_submsgs[1] = {
- {.submsg = &google_protobuf_UninterpretedOption_NamePart_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_UninterpretedOption__fields[7] = {
- {2, UPB_SIZE(56, 80), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(32, 32), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {4, UPB_SIZE(8, 8), 2, 0, 4, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
- {5, UPB_SIZE(16, 16), 3, 0, 3, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
- {6, UPB_SIZE(24, 24), 4, 0, 1, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
- {7, UPB_SIZE(40, 48), 5, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {8, UPB_SIZE(48, 64), 6, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_UninterpretedOption_msginit = {
- &google_protobuf_UninterpretedOption_submsgs[0],
- &google_protobuf_UninterpretedOption__fields[0],
- UPB_SIZE(64, 96), 7, kUpb_ExtMode_NonExtendable, 0, 255, 0,
-};
-
-static const upb_MiniTable_Field google_protobuf_UninterpretedOption_NamePart__fields[2] = {
- {1, UPB_SIZE(4, 8), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(1, 1), 2, 0, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_UninterpretedOption_NamePart_msginit = {
- NULL,
- &google_protobuf_UninterpretedOption_NamePart__fields[0],
- UPB_SIZE(16, 32), 2, kUpb_ExtMode_NonExtendable, 2, 255, 2,
-};
-
-static const upb_MiniTable_Sub google_protobuf_SourceCodeInfo_submsgs[1] = {
- {.submsg = &google_protobuf_SourceCodeInfo_Location_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_SourceCodeInfo__fields[1] = {
- {1, UPB_SIZE(0, 0), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_SourceCodeInfo_msginit = {
- &google_protobuf_SourceCodeInfo_submsgs[0],
- &google_protobuf_SourceCodeInfo__fields[0],
- UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
-};
-
-static const upb_MiniTable_Field google_protobuf_SourceCodeInfo_Location__fields[5] = {
- {1, UPB_SIZE(20, 40), 0, 0, 5, kUpb_FieldMode_Array | kUpb_LabelFlags_IsPacked | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(24, 48), 0, 0, 5, kUpb_FieldMode_Array | kUpb_LabelFlags_IsPacked | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(4, 8), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {4, UPB_SIZE(12, 24), 2, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {6, UPB_SIZE(28, 56), 0, 0, 12, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_SourceCodeInfo_Location_msginit = {
- NULL,
- &google_protobuf_SourceCodeInfo_Location__fields[0],
- UPB_SIZE(32, 64), 5, kUpb_ExtMode_NonExtendable, 4, 255, 0,
-};
-
-static const upb_MiniTable_Sub google_protobuf_GeneratedCodeInfo_submsgs[1] = {
- {.submsg = &google_protobuf_GeneratedCodeInfo_Annotation_msginit},
-};
-
-static const upb_MiniTable_Field google_protobuf_GeneratedCodeInfo__fields[1] = {
- {1, UPB_SIZE(0, 0), 0, 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_GeneratedCodeInfo_msginit = {
- &google_protobuf_GeneratedCodeInfo_submsgs[0],
- &google_protobuf_GeneratedCodeInfo__fields[0],
- UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
-};
-
-static const upb_MiniTable_Field google_protobuf_GeneratedCodeInfo_Annotation__fields[4] = {
- {1, UPB_SIZE(20, 32), 0, 0, 5, kUpb_FieldMode_Array | kUpb_LabelFlags_IsPacked | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
- {2, UPB_SIZE(12, 16), 1, 0, 12, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
- {3, UPB_SIZE(4, 4), 2, 0, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
- {4, UPB_SIZE(8, 8), 3, 0, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
-};
-
-const upb_MiniTable google_protobuf_GeneratedCodeInfo_Annotation_msginit = {
- NULL,
- &google_protobuf_GeneratedCodeInfo_Annotation__fields[0],
- UPB_SIZE(24, 48), 4, kUpb_ExtMode_NonExtendable, 4, 255, 0,
-};
-
-static const upb_MiniTable *messages_layout[27] = {
- &google_protobuf_FileDescriptorSet_msginit,
- &google_protobuf_FileDescriptorProto_msginit,
- &google_protobuf_DescriptorProto_msginit,
- &google_protobuf_DescriptorProto_ExtensionRange_msginit,
- &google_protobuf_DescriptorProto_ReservedRange_msginit,
- &google_protobuf_ExtensionRangeOptions_msginit,
- &google_protobuf_FieldDescriptorProto_msginit,
- &google_protobuf_OneofDescriptorProto_msginit,
- &google_protobuf_EnumDescriptorProto_msginit,
- &google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit,
- &google_protobuf_EnumValueDescriptorProto_msginit,
- &google_protobuf_ServiceDescriptorProto_msginit,
- &google_protobuf_MethodDescriptorProto_msginit,
- &google_protobuf_FileOptions_msginit,
- &google_protobuf_MessageOptions_msginit,
- &google_protobuf_FieldOptions_msginit,
- &google_protobuf_OneofOptions_msginit,
- &google_protobuf_EnumOptions_msginit,
- &google_protobuf_EnumValueOptions_msginit,
- &google_protobuf_ServiceOptions_msginit,
- &google_protobuf_MethodOptions_msginit,
- &google_protobuf_UninterpretedOption_msginit,
- &google_protobuf_UninterpretedOption_NamePart_msginit,
- &google_protobuf_SourceCodeInfo_msginit,
- &google_protobuf_SourceCodeInfo_Location_msginit,
- &google_protobuf_GeneratedCodeInfo_msginit,
- &google_protobuf_GeneratedCodeInfo_Annotation_msginit,
-};
-
-const upb_MiniTable_Enum google_protobuf_FieldDescriptorProto_Type_enuminit = {
- NULL,
- 0x7fffeULL,
- 0,
-};
-
-const upb_MiniTable_Enum google_protobuf_FieldDescriptorProto_Label_enuminit = {
- NULL,
- 0xeULL,
- 0,
-};
-
-const upb_MiniTable_Enum google_protobuf_FileOptions_OptimizeMode_enuminit = {
- NULL,
- 0xeULL,
- 0,
-};
-
-const upb_MiniTable_Enum google_protobuf_FieldOptions_CType_enuminit = {
- NULL,
- 0x7ULL,
- 0,
-};
-
-const upb_MiniTable_Enum google_protobuf_FieldOptions_JSType_enuminit = {
- NULL,
- 0x7ULL,
- 0,
-};
-
-const upb_MiniTable_Enum google_protobuf_MethodOptions_IdempotencyLevel_enuminit = {
- NULL,
- 0x7ULL,
- 0,
-};
-
-static const upb_MiniTable_Enum *enums_layout[6] = {
- &google_protobuf_FieldDescriptorProto_Type_enuminit,
- &google_protobuf_FieldDescriptorProto_Label_enuminit,
- &google_protobuf_FileOptions_OptimizeMode_enuminit,
- &google_protobuf_FieldOptions_CType_enuminit,
- &google_protobuf_FieldOptions_JSType_enuminit,
- &google_protobuf_MethodOptions_IdempotencyLevel_enuminit,
-};
-
-const upb_MiniTable_File google_protobuf_descriptor_proto_upb_file_layout = {
- messages_layout,
- enums_layout,
- NULL,
- 27,
- 6,
- 0,
-};
-
-
-
-/** upb/def.c ************************************************************/
-
-#include <ctype.h>
-#include <errno.h>
-#include <setjmp.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-/* Must be last. */
-
-typedef struct {
- size_t len;
- char str[1]; /* Null-terminated string data follows. */
-} str_t;
-
-/* The upb core does not generally have a concept of default instances. However
- * for descriptor options we make an exception since the max size is known and
- * modest (<200 bytes). All types can share a default instance since it is
- * initialized to zeroes.
- *
- * We have to allocate an extra pointer for upb's internal metadata. */
-static const char opt_default_buf[_UPB_MAXOPT_SIZE + sizeof(void*)] = {0};
-static const char* opt_default = &opt_default_buf[sizeof(void*)];
-
-struct upb_FieldDef {
- const google_protobuf_FieldOptions* opts;
- const upb_FileDef* file;
- const upb_MessageDef* msgdef;
- const char* full_name;
- const char* json_name;
- union {
- int64_t sint;
- uint64_t uint;
- double dbl;
- float flt;
- bool boolean;
- str_t* str;
- } defaultval;
- union {
- const upb_OneofDef* oneof;
- const upb_MessageDef* extension_scope;
- } scope;
- union {
- const upb_MessageDef* msgdef;
- const upb_EnumDef* enumdef;
- const google_protobuf_FieldDescriptorProto* unresolved;
- } sub;
- uint32_t number_;
- uint16_t index_;
- uint16_t layout_index; /* Index into msgdef->layout->fields or file->exts */
- bool has_default;
- bool is_extension_;
- bool packed_;
- bool proto3_optional_;
- bool has_json_name_;
- upb_FieldType type_;
- upb_Label label_;
-#if UINTPTR_MAX == 0xffffffff
- uint32_t padding; // Increase size to a multiple of 8.
-#endif
-};
-
-struct upb_ExtensionRange {
- const google_protobuf_ExtensionRangeOptions* opts;
- int32_t start;
- int32_t end;
-};
-
-struct upb_MessageDef {
- const google_protobuf_MessageOptions* opts;
- const upb_MiniTable* layout;
- const upb_FileDef* file;
- const upb_MessageDef* containing_type;
- const char* full_name;
-
- /* Tables for looking up fields by number and name. */
- upb_inttable itof;
- upb_strtable ntof;
-
- /* All nested defs.
- * MEM: We could save some space here by putting nested defs in a contiguous
- * region and calculating counts from offsets or vice-versa. */
- const upb_FieldDef* fields;
- const upb_OneofDef* oneofs;
- const upb_ExtensionRange* ext_ranges;
- const upb_MessageDef* nested_msgs;
- const upb_EnumDef* nested_enums;
- const upb_FieldDef* nested_exts;
- int field_count;
- int real_oneof_count;
- int oneof_count;
- int ext_range_count;
- int nested_msg_count;
- int nested_enum_count;
- int nested_ext_count;
- bool in_message_set;
- upb_WellKnown well_known_type;
-#if UINTPTR_MAX == 0xffffffff
- uint32_t padding; // Increase size to a multiple of 8.
-#endif
-};
-
-struct upb_EnumDef {
- const google_protobuf_EnumOptions* opts;
- const upb_MiniTable_Enum* layout; // Only for proto2.
- const upb_FileDef* file;
- const upb_MessageDef* containing_type; // Could be merged with "file".
- const char* full_name;
- upb_strtable ntoi;
- upb_inttable iton;
- const upb_EnumValueDef* values;
- int value_count;
- int32_t defaultval;
-#if UINTPTR_MAX == 0xffffffff
- uint32_t padding; // Increase size to a multiple of 8.
-#endif
-};
-
-struct upb_EnumValueDef {
- const google_protobuf_EnumValueOptions* opts;
- const upb_EnumDef* parent;
- const char* full_name;
- int32_t number;
-};
-
-struct upb_OneofDef {
- const google_protobuf_OneofOptions* opts;
- const upb_MessageDef* parent;
- const char* full_name;
- int field_count;
- bool synthetic;
- const upb_FieldDef** fields;
- upb_strtable ntof;
- upb_inttable itof;
-#if UINTPTR_MAX == 0xffffffff
- uint32_t padding; // Increase size to a multiple of 8.
-#endif
-};
-
-struct upb_FileDef {
- const google_protobuf_FileOptions* opts;
- const char* name;
- const char* package;
-
- const upb_FileDef** deps;
- const int32_t* public_deps;
- const int32_t* weak_deps;
- const upb_MessageDef* top_lvl_msgs;
- const upb_EnumDef* top_lvl_enums;
- const upb_FieldDef* top_lvl_exts;
- const upb_ServiceDef* services;
- const upb_MiniTable_Extension** ext_layouts;
- const upb_DefPool* symtab;
-
- int dep_count;
- int public_dep_count;
- int weak_dep_count;
- int top_lvl_msg_count;
- int top_lvl_enum_count;
- int top_lvl_ext_count;
- int service_count;
- int ext_count; /* All exts in the file. */
- upb_Syntax syntax;
-};
-
-struct upb_MethodDef {
- const google_protobuf_MethodOptions* opts;
- upb_ServiceDef* service;
- const char* full_name;
- const upb_MessageDef* input_type;
- const upb_MessageDef* output_type;
- int index;
- bool client_streaming;
- bool server_streaming;
-};
-
-struct upb_ServiceDef {
- const google_protobuf_ServiceOptions* opts;
- const upb_FileDef* file;
- const char* full_name;
- upb_MethodDef* methods;
- int method_count;
- int index;
-};
-
-struct upb_DefPool {
- upb_Arena* arena;
- upb_strtable syms; /* full_name -> packed def ptr */
- upb_strtable files; /* file_name -> upb_FileDef* */
- upb_inttable exts; /* upb_MiniTable_Extension* -> upb_FieldDef* */
- upb_ExtensionRegistry* extreg;
- size_t bytes_loaded;
-};
-
-/* Inside a symtab we store tagged pointers to specific def types. */
-typedef enum {
- UPB_DEFTYPE_MASK = 7,
-
- /* Only inside symtab table. */
- UPB_DEFTYPE_EXT = 0,
- UPB_DEFTYPE_MSG = 1,
- UPB_DEFTYPE_ENUM = 2,
- UPB_DEFTYPE_ENUMVAL = 3,
- UPB_DEFTYPE_SERVICE = 4,
-
- /* Only inside message table. */
- UPB_DEFTYPE_FIELD = 0,
- UPB_DEFTYPE_ONEOF = 1,
- UPB_DEFTYPE_FIELD_JSONNAME = 2,
-
- /* Only inside file table. */
- UPB_DEFTYPE_FILE = 0,
- UPB_DEFTYPE_LAYOUT = 1
-} upb_deftype_t;
-
-#define FIELD_TYPE_UNSPECIFIED 0
-
-static upb_deftype_t deftype(upb_value v) {
- uintptr_t num = (uintptr_t)upb_value_getconstptr(v);
- return num & UPB_DEFTYPE_MASK;
-}
-
-static const void* unpack_def(upb_value v, upb_deftype_t type) {
- uintptr_t num = (uintptr_t)upb_value_getconstptr(v);
- return (num & UPB_DEFTYPE_MASK) == type
- ? (const void*)(num & ~UPB_DEFTYPE_MASK)
- : NULL;
-}
-
-static upb_value pack_def(const void* ptr, upb_deftype_t type) {
- // Our 3-bit pointer tagging requires all pointers to be multiples of 8.
- // The arena will always yield 8-byte-aligned addresses, however we put
- // the defs into arrays. For each element in the array to be 8-byte-aligned,
- // the sizes of each def type must also be a multiple of 8.
- //
- // If any of these asserts fail, we need to add or remove padding on 32-bit
- // machines (64-bit machines will have 8-byte alignment already due to
- // pointers, which all of these structs have).
- UPB_ASSERT((sizeof(upb_FieldDef) & UPB_DEFTYPE_MASK) == 0);
- UPB_ASSERT((sizeof(upb_MessageDef) & UPB_DEFTYPE_MASK) == 0);
- UPB_ASSERT((sizeof(upb_EnumDef) & UPB_DEFTYPE_MASK) == 0);
- UPB_ASSERT((sizeof(upb_EnumValueDef) & UPB_DEFTYPE_MASK) == 0);
- UPB_ASSERT((sizeof(upb_ServiceDef) & UPB_DEFTYPE_MASK) == 0);
- UPB_ASSERT((sizeof(upb_OneofDef) & UPB_DEFTYPE_MASK) == 0);
- uintptr_t num = (uintptr_t)ptr;
- UPB_ASSERT((num & UPB_DEFTYPE_MASK) == 0);
- num |= type;
- return upb_value_constptr((const void*)num);
-}
-
-/* isalpha() etc. from <ctype.h> are locale-dependent, which we don't want. */
-static bool upb_isbetween(uint8_t c, uint8_t low, uint8_t high) {
- return c >= low && c <= high;
-}
-
-static char upb_ascii_lower(char ch) {
- // Per ASCII this will lower-case a letter. If the result is a letter, the
- // input was definitely a letter. If the output is not a letter, this may
- // have transformed the character unpredictably.
- return ch | 0x20;
-}
-
-static bool upb_isletter(char c) {
- char lower = upb_ascii_lower(c);
- return upb_isbetween(lower, 'a', 'z') || c == '_';
-}
-
-static bool upb_isalphanum(char c) {
- return upb_isletter(c) || upb_isbetween(c, '0', '9');
-}
-
-static const char* shortdefname(const char* fullname) {
- const char* p;
-
- if (fullname == NULL) {
- return NULL;
- } else if ((p = strrchr(fullname, '.')) == NULL) {
- /* No '.' in the name, return the full string. */
- return fullname;
- } else {
- /* Return one past the last '.'. */
- return p + 1;
- }
-}
-
-/* All submessage fields are lower than all other fields.
- * Secondly, fields are increasing in order. */
-uint32_t field_rank(const upb_FieldDef* f) {
- uint32_t ret = upb_FieldDef_Number(f);
- const uint32_t high_bit = 1 << 30;
- UPB_ASSERT(ret < high_bit);
- if (!upb_FieldDef_IsSubMessage(f)) ret |= high_bit;
- return ret;
-}
-
-int cmp_fields(const void* p1, const void* p2) {
- const upb_FieldDef* f1 = *(upb_FieldDef* const*)p1;
- const upb_FieldDef* f2 = *(upb_FieldDef* const*)p2;
- return field_rank(f1) - field_rank(f2);
-}
-
-static void upb_Status_setoom(upb_Status* status) {
- upb_Status_SetErrorMessage(status, "out of memory");
-}
-
-static void assign_msg_wellknowntype(upb_MessageDef* m) {
- const char* name = upb_MessageDef_FullName(m);
- if (name == NULL) {
- m->well_known_type = kUpb_WellKnown_Unspecified;
- return;
- }
- if (!strcmp(name, "google.protobuf.Any")) {
- m->well_known_type = kUpb_WellKnown_Any;
- } else if (!strcmp(name, "google.protobuf.FieldMask")) {
- m->well_known_type = kUpb_WellKnown_FieldMask;
- } else if (!strcmp(name, "google.protobuf.Duration")) {
- m->well_known_type = kUpb_WellKnown_Duration;
- } else if (!strcmp(name, "google.protobuf.Timestamp")) {
- m->well_known_type = kUpb_WellKnown_Timestamp;
- } else if (!strcmp(name, "google.protobuf.DoubleValue")) {
- m->well_known_type = kUpb_WellKnown_DoubleValue;
- } else if (!strcmp(name, "google.protobuf.FloatValue")) {
- m->well_known_type = kUpb_WellKnown_FloatValue;
- } else if (!strcmp(name, "google.protobuf.Int64Value")) {
- m->well_known_type = kUpb_WellKnown_Int64Value;
- } else if (!strcmp(name, "google.protobuf.UInt64Value")) {
- m->well_known_type = kUpb_WellKnown_UInt64Value;
- } else if (!strcmp(name, "google.protobuf.Int32Value")) {
- m->well_known_type = kUpb_WellKnown_Int32Value;
- } else if (!strcmp(name, "google.protobuf.UInt32Value")) {
- m->well_known_type = kUpb_WellKnown_UInt32Value;
- } else if (!strcmp(name, "google.protobuf.BoolValue")) {
- m->well_known_type = kUpb_WellKnown_BoolValue;
- } else if (!strcmp(name, "google.protobuf.StringValue")) {
- m->well_known_type = kUpb_WellKnown_StringValue;
- } else if (!strcmp(name, "google.protobuf.BytesValue")) {
- m->well_known_type = kUpb_WellKnown_BytesValue;
- } else if (!strcmp(name, "google.protobuf.Value")) {
- m->well_known_type = kUpb_WellKnown_Value;
- } else if (!strcmp(name, "google.protobuf.ListValue")) {
- m->well_known_type = kUpb_WellKnown_ListValue;
- } else if (!strcmp(name, "google.protobuf.Struct")) {
- m->well_known_type = kUpb_WellKnown_Struct;
- } else {
- m->well_known_type = kUpb_WellKnown_Unspecified;
- }
-}
-
-/* upb_EnumDef ****************************************************************/
-
-const google_protobuf_EnumOptions* upb_EnumDef_Options(const upb_EnumDef* e) {
- return e->opts;
-}
-
-bool upb_EnumDef_HasOptions(const upb_EnumDef* e) {
- return e->opts != (void*)opt_default;
-}
-
-const char* upb_EnumDef_FullName(const upb_EnumDef* e) { return e->full_name; }
-
-const char* upb_EnumDef_Name(const upb_EnumDef* e) {
- return shortdefname(e->full_name);
-}
-
-const upb_FileDef* upb_EnumDef_File(const upb_EnumDef* e) { return e->file; }
-
-const upb_MessageDef* upb_EnumDef_ContainingType(const upb_EnumDef* e) {
- return e->containing_type;
-}
-
-int32_t upb_EnumDef_Default(const upb_EnumDef* e) {
- UPB_ASSERT(upb_EnumDef_FindValueByNumber(e, e->defaultval));
- return e->defaultval;
-}
-
-int upb_EnumDef_ValueCount(const upb_EnumDef* e) { return e->value_count; }
-
-const upb_EnumValueDef* upb_EnumDef_FindValueByNameWithSize(
- const upb_EnumDef* def, const char* name, size_t len) {
- upb_value v;
- return upb_strtable_lookup2(&def->ntoi, name, len, &v)
- ? upb_value_getconstptr(v)
- : NULL;
-}
-
-const upb_EnumValueDef* upb_EnumDef_FindValueByNumber(const upb_EnumDef* def,
- int32_t num) {
- upb_value v;
- return upb_inttable_lookup(&def->iton, num, &v) ? upb_value_getconstptr(v)
- : NULL;
-}
-
-bool upb_EnumDef_CheckNumber(const upb_EnumDef* e, int32_t num) {
- // We could use upb_EnumDef_FindValueByNumber(e, num) != NULL, but we expect
- // this to be faster (especially for small numbers).
- return upb_MiniTable_Enum_CheckValue(e->layout, num);
-}
-
-const upb_EnumValueDef* upb_EnumDef_Value(const upb_EnumDef* e, int i) {
- UPB_ASSERT(0 <= i && i < e->value_count);
- return &e->values[i];
-}
-
-/* upb_EnumValueDef ***********************************************************/
-
-const google_protobuf_EnumValueOptions* upb_EnumValueDef_Options(
- const upb_EnumValueDef* e) {
- return e->opts;
-}
-
-bool upb_EnumValueDef_HasOptions(const upb_EnumValueDef* e) {
- return e->opts != (void*)opt_default;
-}
-
-const upb_EnumDef* upb_EnumValueDef_Enum(const upb_EnumValueDef* ev) {
- return ev->parent;
-}
-
-const char* upb_EnumValueDef_FullName(const upb_EnumValueDef* ev) {
- return ev->full_name;
-}
-
-const char* upb_EnumValueDef_Name(const upb_EnumValueDef* ev) {
- return shortdefname(ev->full_name);
-}
-
-int32_t upb_EnumValueDef_Number(const upb_EnumValueDef* ev) {
- return ev->number;
-}
-
-uint32_t upb_EnumValueDef_Index(const upb_EnumValueDef* ev) {
- // Compute index in our parent's array.
- return ev - ev->parent->values;
-}
-
-/* upb_ExtensionRange
- * ***************************************************************/
-
-const google_protobuf_ExtensionRangeOptions* upb_ExtensionRange_Options(
- const upb_ExtensionRange* r) {
- return r->opts;
-}
-
-bool upb_ExtensionRange_HasOptions(const upb_ExtensionRange* r) {
- return r->opts != (void*)opt_default;
-}
-
-int32_t upb_ExtensionRange_Start(const upb_ExtensionRange* e) {
- return e->start;
-}
-
-int32_t upb_ExtensionRange_End(const upb_ExtensionRange* e) { return e->end; }
-
-/* upb_FieldDef ***************************************************************/
-
-const google_protobuf_FieldOptions* upb_FieldDef_Options(
- const upb_FieldDef* f) {
- return f->opts;
-}
-
-bool upb_FieldDef_HasOptions(const upb_FieldDef* f) {
- return f->opts != (void*)opt_default;
-}
-
-const char* upb_FieldDef_FullName(const upb_FieldDef* f) {
- return f->full_name;
-}
-
-upb_CType upb_FieldDef_CType(const upb_FieldDef* f) {
- switch (f->type_) {
- case kUpb_FieldType_Double:
- return kUpb_CType_Double;
- case kUpb_FieldType_Float:
- return kUpb_CType_Float;
- case kUpb_FieldType_Int64:
- case kUpb_FieldType_SInt64:
- case kUpb_FieldType_SFixed64:
- return kUpb_CType_Int64;
- case kUpb_FieldType_Int32:
- case kUpb_FieldType_SFixed32:
- case kUpb_FieldType_SInt32:
- return kUpb_CType_Int32;
- case kUpb_FieldType_UInt64:
- case kUpb_FieldType_Fixed64:
- return kUpb_CType_UInt64;
- case kUpb_FieldType_UInt32:
- case kUpb_FieldType_Fixed32:
- return kUpb_CType_UInt32;
- case kUpb_FieldType_Enum:
- return kUpb_CType_Enum;
- case kUpb_FieldType_Bool:
- return kUpb_CType_Bool;
- case kUpb_FieldType_String:
- return kUpb_CType_String;
- case kUpb_FieldType_Bytes:
- return kUpb_CType_Bytes;
- case kUpb_FieldType_Group:
- case kUpb_FieldType_Message:
- return kUpb_CType_Message;
- }
- UPB_UNREACHABLE();
-}
-
-upb_FieldType upb_FieldDef_Type(const upb_FieldDef* f) { return f->type_; }
-
-uint32_t upb_FieldDef_Index(const upb_FieldDef* f) { return f->index_; }
-
-upb_Label upb_FieldDef_Label(const upb_FieldDef* f) { return f->label_; }
-
-uint32_t upb_FieldDef_Number(const upb_FieldDef* f) { return f->number_; }
-
-bool upb_FieldDef_IsExtension(const upb_FieldDef* f) {
- return f->is_extension_;
-}
-
-bool upb_FieldDef_IsPacked(const upb_FieldDef* f) { return f->packed_; }
-
-const char* upb_FieldDef_Name(const upb_FieldDef* f) {
- return shortdefname(f->full_name);
-}
-
-const char* upb_FieldDef_JsonName(const upb_FieldDef* f) {
- return f->json_name;
-}
-
-bool upb_FieldDef_HasJsonName(const upb_FieldDef* f) {
- return f->has_json_name_;
-}
-
-const upb_FileDef* upb_FieldDef_File(const upb_FieldDef* f) { return f->file; }
-
-const upb_MessageDef* upb_FieldDef_ContainingType(const upb_FieldDef* f) {
- return f->msgdef;
-}
-
-const upb_MessageDef* upb_FieldDef_ExtensionScope(const upb_FieldDef* f) {
- return f->is_extension_ ? f->scope.extension_scope : NULL;
-}
-
-const upb_OneofDef* upb_FieldDef_ContainingOneof(const upb_FieldDef* f) {
- return f->is_extension_ ? NULL : f->scope.oneof;
-}
-
-const upb_OneofDef* upb_FieldDef_RealContainingOneof(const upb_FieldDef* f) {
- const upb_OneofDef* oneof = upb_FieldDef_ContainingOneof(f);
- if (!oneof || upb_OneofDef_IsSynthetic(oneof)) return NULL;
- return oneof;
-}
-
-upb_MessageValue upb_FieldDef_Default(const upb_FieldDef* f) {
- UPB_ASSERT(!upb_FieldDef_IsSubMessage(f));
- upb_MessageValue ret;
-
- switch (upb_FieldDef_CType(f)) {
- case kUpb_CType_Bool:
- return (upb_MessageValue){.bool_val = f->defaultval.boolean};
- case kUpb_CType_Int64:
- return (upb_MessageValue){.int64_val = f->defaultval.sint};
- case kUpb_CType_UInt64:
- return (upb_MessageValue){.uint64_val = f->defaultval.uint};
- case kUpb_CType_Enum:
- case kUpb_CType_Int32:
- return (upb_MessageValue){.int32_val = (int32_t)f->defaultval.sint};
- case kUpb_CType_UInt32:
- return (upb_MessageValue){.uint32_val = (uint32_t)f->defaultval.uint};
- case kUpb_CType_Float:
- return (upb_MessageValue){.float_val = f->defaultval.flt};
- case kUpb_CType_Double:
- return (upb_MessageValue){.double_val = f->defaultval.dbl};
- case kUpb_CType_String:
- case kUpb_CType_Bytes: {
- str_t* str = f->defaultval.str;
- if (str) {
- return (upb_MessageValue){
- .str_val = (upb_StringView){.data = str->str, .size = str->len}};
- } else {
- return (upb_MessageValue){
- .str_val = (upb_StringView){.data = NULL, .size = 0}};
- }
- }
- default:
- UPB_UNREACHABLE();
- }
-
- return ret;
-}
-
-const upb_MessageDef* upb_FieldDef_MessageSubDef(const upb_FieldDef* f) {
- return upb_FieldDef_CType(f) == kUpb_CType_Message ? f->sub.msgdef : NULL;
-}
-
-const upb_EnumDef* upb_FieldDef_EnumSubDef(const upb_FieldDef* f) {
- return upb_FieldDef_CType(f) == kUpb_CType_Enum ? f->sub.enumdef : NULL;
-}
-
-const upb_MiniTable_Field* upb_FieldDef_MiniTable(const upb_FieldDef* f) {
- UPB_ASSERT(!upb_FieldDef_IsExtension(f));
- return &f->msgdef->layout->fields[f->layout_index];
-}
-
-const upb_MiniTable_Extension* _upb_FieldDef_ExtensionMiniTable(
- const upb_FieldDef* f) {
- UPB_ASSERT(upb_FieldDef_IsExtension(f));
- return f->file->ext_layouts[f->layout_index];
-}
-
-bool _upb_FieldDef_IsProto3Optional(const upb_FieldDef* f) {
- return f->proto3_optional_;
-}
-
-bool upb_FieldDef_IsSubMessage(const upb_FieldDef* f) {
- return upb_FieldDef_CType(f) == kUpb_CType_Message;
-}
-
-bool upb_FieldDef_IsString(const upb_FieldDef* f) {
- return upb_FieldDef_CType(f) == kUpb_CType_String ||
- upb_FieldDef_CType(f) == kUpb_CType_Bytes;
-}
-
-bool upb_FieldDef_IsRepeated(const upb_FieldDef* f) {
- return upb_FieldDef_Label(f) == kUpb_Label_Repeated;
-}
-
-bool upb_FieldDef_IsPrimitive(const upb_FieldDef* f) {
- return !upb_FieldDef_IsString(f) && !upb_FieldDef_IsSubMessage(f);
-}
-
-bool upb_FieldDef_IsMap(const upb_FieldDef* f) {
- return upb_FieldDef_IsRepeated(f) && upb_FieldDef_IsSubMessage(f) &&
- upb_MessageDef_IsMapEntry(upb_FieldDef_MessageSubDef(f));
-}
-
-bool upb_FieldDef_HasDefault(const upb_FieldDef* f) { return f->has_default; }
-
-bool upb_FieldDef_HasSubDef(const upb_FieldDef* f) {
- return upb_FieldDef_IsSubMessage(f) ||
- upb_FieldDef_CType(f) == kUpb_CType_Enum;
-}
-
-bool upb_FieldDef_HasPresence(const upb_FieldDef* f) {
- if (upb_FieldDef_IsRepeated(f)) return false;
- return upb_FieldDef_IsSubMessage(f) || upb_FieldDef_ContainingOneof(f) ||
- f->file->syntax == kUpb_Syntax_Proto2;
-}
-
-static bool between(int32_t x, int32_t low, int32_t high) {
- return x >= low && x <= high;
-}
-
-bool upb_FieldDef_checklabel(int32_t label) { return between(label, 1, 3); }
-bool upb_FieldDef_checktype(int32_t type) { return between(type, 1, 11); }
-bool upb_FieldDef_checkintfmt(int32_t fmt) { return between(fmt, 1, 3); }
-
-bool upb_FieldDef_checkdescriptortype(int32_t type) {
- return between(type, 1, 18);
-}
-
-/* upb_MessageDef
- * *****************************************************************/
-
-const google_protobuf_MessageOptions* upb_MessageDef_Options(
- const upb_MessageDef* m) {
- return m->opts;
-}
-
-bool upb_MessageDef_HasOptions(const upb_MessageDef* m) {
- return m->opts != (void*)opt_default;
-}
-
-const char* upb_MessageDef_FullName(const upb_MessageDef* m) {
- return m->full_name;
-}
-
-const upb_FileDef* upb_MessageDef_File(const upb_MessageDef* m) {
- return m->file;
-}
-
-const upb_MessageDef* upb_MessageDef_ContainingType(const upb_MessageDef* m) {
- return m->containing_type;
-}
-
-const char* upb_MessageDef_Name(const upb_MessageDef* m) {
- return shortdefname(m->full_name);
-}
-
-upb_Syntax upb_MessageDef_Syntax(const upb_MessageDef* m) {
- return m->file->syntax;
-}
-
-const upb_FieldDef* upb_MessageDef_FindFieldByNumber(const upb_MessageDef* m,
- uint32_t i) {
- upb_value val;
- return upb_inttable_lookup(&m->itof, i, &val) ? upb_value_getconstptr(val)
- : NULL;
-}
-
-const upb_FieldDef* upb_MessageDef_FindFieldByNameWithSize(
- const upb_MessageDef* m, const char* name, size_t len) {
- upb_value val;
-
- if (!upb_strtable_lookup2(&m->ntof, name, len, &val)) {
- return NULL;
- }
-
- return unpack_def(val, UPB_DEFTYPE_FIELD);
-}
-
-const upb_OneofDef* upb_MessageDef_FindOneofByNameWithSize(
- const upb_MessageDef* m, const char* name, size_t len) {
- upb_value val;
-
- if (!upb_strtable_lookup2(&m->ntof, name, len, &val)) {
- return NULL;
- }
-
- return unpack_def(val, UPB_DEFTYPE_ONEOF);
-}
-
-bool upb_MessageDef_FindByNameWithSize(const upb_MessageDef* m,
- const char* name, size_t len,
- const upb_FieldDef** out_f,
- const upb_OneofDef** out_o) {
- upb_value val;
-
- if (!upb_strtable_lookup2(&m->ntof, name, len, &val)) {
- return false;
- }
-
- const upb_FieldDef* f = unpack_def(val, UPB_DEFTYPE_FIELD);
- const upb_OneofDef* o = unpack_def(val, UPB_DEFTYPE_ONEOF);
- if (out_f) *out_f = f;
- if (out_o) *out_o = o;
- return f || o; /* False if this was a JSON name. */
-}
-
-const upb_FieldDef* upb_MessageDef_FindByJsonNameWithSize(
- const upb_MessageDef* m, const char* name, size_t len) {
- upb_value val;
- const upb_FieldDef* f;
-
- if (!upb_strtable_lookup2(&m->ntof, name, len, &val)) {
- return NULL;
- }
-
- f = unpack_def(val, UPB_DEFTYPE_FIELD);
- if (!f) f = unpack_def(val, UPB_DEFTYPE_FIELD_JSONNAME);
-
- return f;
-}
-
-int upb_MessageDef_numfields(const upb_MessageDef* m) { return m->field_count; }
-
-int upb_MessageDef_numoneofs(const upb_MessageDef* m) { return m->oneof_count; }
-
-int upb_MessageDef_numrealoneofs(const upb_MessageDef* m) {
- return m->real_oneof_count;
-}
-
-int upb_MessageDef_ExtensionRangeCount(const upb_MessageDef* m) {
- return m->ext_range_count;
-}
-
-int upb_MessageDef_FieldCount(const upb_MessageDef* m) {
- return m->field_count;
-}
-
-int upb_MessageDef_OneofCount(const upb_MessageDef* m) {
- return m->oneof_count;
-}
-
-int upb_MessageDef_NestedMessageCount(const upb_MessageDef* m) {
- return m->nested_msg_count;
-}
-
-int upb_MessageDef_NestedEnumCount(const upb_MessageDef* m) {
- return m->nested_enum_count;
-}
-
-int upb_MessageDef_NestedExtensionCount(const upb_MessageDef* m) {
- return m->nested_ext_count;
-}
-
-int upb_MessageDef_realoneofcount(const upb_MessageDef* m) {
- return m->real_oneof_count;
-}
-
-const upb_MiniTable* upb_MessageDef_MiniTable(const upb_MessageDef* m) {
- return m->layout;
-}
-
-const upb_ExtensionRange* upb_MessageDef_ExtensionRange(const upb_MessageDef* m,
- int i) {
- UPB_ASSERT(0 <= i && i < m->ext_range_count);
- return &m->ext_ranges[i];
-}
-
-const upb_FieldDef* upb_MessageDef_Field(const upb_MessageDef* m, int i) {
- UPB_ASSERT(0 <= i && i < m->field_count);
- return &m->fields[i];
-}
-
-const upb_OneofDef* upb_MessageDef_Oneof(const upb_MessageDef* m, int i) {
- UPB_ASSERT(0 <= i && i < m->oneof_count);
- return &m->oneofs[i];
-}
-
-const upb_MessageDef* upb_MessageDef_NestedMessage(const upb_MessageDef* m,
- int i) {
- UPB_ASSERT(0 <= i && i < m->nested_msg_count);
- return &m->nested_msgs[i];
-}
-
-const upb_EnumDef* upb_MessageDef_NestedEnum(const upb_MessageDef* m, int i) {
- UPB_ASSERT(0 <= i && i < m->nested_enum_count);
- return &m->nested_enums[i];
-}
-
-const upb_FieldDef* upb_MessageDef_NestedExtension(const upb_MessageDef* m,
- int i) {
- UPB_ASSERT(0 <= i && i < m->nested_ext_count);
- return &m->nested_exts[i];
-}
-
-upb_WellKnown upb_MessageDef_WellKnownType(const upb_MessageDef* m) {
- return m->well_known_type;
-}
-
-/* upb_OneofDef ***************************************************************/
-
-const google_protobuf_OneofOptions* upb_OneofDef_Options(
- const upb_OneofDef* o) {
- return o->opts;
-}
-
-bool upb_OneofDef_HasOptions(const upb_OneofDef* o) {
- return o->opts != (void*)opt_default;
-}
-
-const char* upb_OneofDef_Name(const upb_OneofDef* o) {
- return shortdefname(o->full_name);
-}
-
-const upb_MessageDef* upb_OneofDef_ContainingType(const upb_OneofDef* o) {
- return o->parent;
-}
-
-int upb_OneofDef_FieldCount(const upb_OneofDef* o) { return o->field_count; }
-
-const upb_FieldDef* upb_OneofDef_Field(const upb_OneofDef* o, int i) {
- UPB_ASSERT(i < o->field_count);
- return o->fields[i];
-}
-
-int upb_OneofDef_numfields(const upb_OneofDef* o) { return o->field_count; }
-
-uint32_t upb_OneofDef_Index(const upb_OneofDef* o) {
- // Compute index in our parent's array.
- return o - o->parent->oneofs;
-}
-
-bool upb_OneofDef_IsSynthetic(const upb_OneofDef* o) { return o->synthetic; }
-
-const upb_FieldDef* upb_OneofDef_LookupNameWithSize(const upb_OneofDef* o,
- const char* name,
- size_t length) {
- upb_value val;
- return upb_strtable_lookup2(&o->ntof, name, length, &val)
- ? upb_value_getptr(val)
- : NULL;
-}
-
-const upb_FieldDef* upb_OneofDef_LookupNumber(const upb_OneofDef* o,
- uint32_t num) {
- upb_value val;
- return upb_inttable_lookup(&o->itof, num, &val) ? upb_value_getptr(val)
- : NULL;
-}
-
-/* upb_FileDef ****************************************************************/
-
-const google_protobuf_FileOptions* upb_FileDef_Options(const upb_FileDef* f) {
- return f->opts;
-}
-
-bool upb_FileDef_HasOptions(const upb_FileDef* f) {
- return f->opts != (void*)opt_default;
-}
-
-const char* upb_FileDef_Name(const upb_FileDef* f) { return f->name; }
-
-const char* upb_FileDef_Package(const upb_FileDef* f) { return f->package; }
-
-upb_Syntax upb_FileDef_Syntax(const upb_FileDef* f) { return f->syntax; }
-
-int upb_FileDef_TopLevelMessageCount(const upb_FileDef* f) {
- return f->top_lvl_msg_count;
-}
-
-int upb_FileDef_DependencyCount(const upb_FileDef* f) { return f->dep_count; }
-
-int upb_FileDef_PublicDependencyCount(const upb_FileDef* f) {
- return f->public_dep_count;
-}
-
-int upb_FileDef_WeakDependencyCount(const upb_FileDef* f) {
- return f->weak_dep_count;
-}
-
-const int32_t* _upb_FileDef_PublicDependencyIndexes(const upb_FileDef* f) {
- return f->public_deps;
-}
-
-const int32_t* _upb_FileDef_WeakDependencyIndexes(const upb_FileDef* f) {
- return f->weak_deps;
-}
-
-int upb_FileDef_TopLevelEnumCount(const upb_FileDef* f) {
- return f->top_lvl_enum_count;
-}
-
-int upb_FileDef_TopLevelExtensionCount(const upb_FileDef* f) {
- return f->top_lvl_ext_count;
-}
-
-int upb_FileDef_ServiceCount(const upb_FileDef* f) { return f->service_count; }
-
-const upb_FileDef* upb_FileDef_Dependency(const upb_FileDef* f, int i) {
- UPB_ASSERT(0 <= i && i < f->dep_count);
- return f->deps[i];
-}
-
-const upb_FileDef* upb_FileDef_PublicDependency(const upb_FileDef* f, int i) {
- UPB_ASSERT(0 <= i && i < f->public_dep_count);
- return f->deps[f->public_deps[i]];
-}
-
-const upb_FileDef* upb_FileDef_WeakDependency(const upb_FileDef* f, int i) {
- UPB_ASSERT(0 <= i && i < f->public_dep_count);
- return f->deps[f->weak_deps[i]];
-}
-
-const upb_MessageDef* upb_FileDef_TopLevelMessage(const upb_FileDef* f, int i) {
- UPB_ASSERT(0 <= i && i < f->top_lvl_msg_count);
- return &f->top_lvl_msgs[i];
-}
-
-const upb_EnumDef* upb_FileDef_TopLevelEnum(const upb_FileDef* f, int i) {
- UPB_ASSERT(0 <= i && i < f->top_lvl_enum_count);
- return &f->top_lvl_enums[i];
-}
-
-const upb_FieldDef* upb_FileDef_TopLevelExtension(const upb_FileDef* f, int i) {
- UPB_ASSERT(0 <= i && i < f->top_lvl_ext_count);
- return &f->top_lvl_exts[i];
-}
-
-const upb_ServiceDef* upb_FileDef_Service(const upb_FileDef* f, int i) {
- UPB_ASSERT(0 <= i && i < f->service_count);
- return &f->services[i];
-}
-
-const upb_DefPool* upb_FileDef_Pool(const upb_FileDef* f) { return f->symtab; }
-
-/* upb_MethodDef **************************************************************/
-
-const google_protobuf_MethodOptions* upb_MethodDef_Options(
- const upb_MethodDef* m) {
- return m->opts;
-}
-
-bool upb_MethodDef_HasOptions(const upb_MethodDef* m) {
- return m->opts != (void*)opt_default;
-}
-
-const char* upb_MethodDef_FullName(const upb_MethodDef* m) {
- return m->full_name;
-}
-
-int upb_MethodDef_Index(const upb_MethodDef* m) { return m->index; }
-
-const char* upb_MethodDef_Name(const upb_MethodDef* m) {
- return shortdefname(m->full_name);
-}
-
-const upb_ServiceDef* upb_MethodDef_Service(const upb_MethodDef* m) {
- return m->service;
-}
-
-const upb_MessageDef* upb_MethodDef_InputType(const upb_MethodDef* m) {
- return m->input_type;
-}
-
-const upb_MessageDef* upb_MethodDef_OutputType(const upb_MethodDef* m) {
- return m->output_type;
-}
-
-bool upb_MethodDef_ClientStreaming(const upb_MethodDef* m) {
- return m->client_streaming;
-}
-
-bool upb_MethodDef_ServerStreaming(const upb_MethodDef* m) {
- return m->server_streaming;
-}
-
-/* upb_ServiceDef *************************************************************/
-
-const google_protobuf_ServiceOptions* upb_ServiceDef_Options(
- const upb_ServiceDef* s) {
- return s->opts;
-}
-
-bool upb_ServiceDef_HasOptions(const upb_ServiceDef* s) {
- return s->opts != (void*)opt_default;
-}
-
-const char* upb_ServiceDef_FullName(const upb_ServiceDef* s) {
- return s->full_name;
-}
-
-const char* upb_ServiceDef_Name(const upb_ServiceDef* s) {
- return shortdefname(s->full_name);
-}
-
-int upb_ServiceDef_Index(const upb_ServiceDef* s) { return s->index; }
-
-const upb_FileDef* upb_ServiceDef_File(const upb_ServiceDef* s) {
- return s->file;
-}
-
-int upb_ServiceDef_MethodCount(const upb_ServiceDef* s) {
- return s->method_count;
-}
-
-const upb_MethodDef* upb_ServiceDef_Method(const upb_ServiceDef* s, int i) {
- return i < 0 || i >= s->method_count ? NULL : &s->methods[i];
-}
-
-const upb_MethodDef* upb_ServiceDef_FindMethodByName(const upb_ServiceDef* s,
- const char* name) {
- for (int i = 0; i < s->method_count; i++) {
- if (strcmp(name, upb_MethodDef_Name(&s->methods[i])) == 0) {
- return &s->methods[i];
- }
- }
- return NULL;
-}
-
-/* upb_DefPool ****************************************************************/
-
-void upb_DefPool_Free(upb_DefPool* s) {
- upb_Arena_Free(s->arena);
- upb_gfree(s);
-}
-
-upb_DefPool* upb_DefPool_New(void) {
- upb_DefPool* s = upb_gmalloc(sizeof(*s));
-
- if (!s) {
- return NULL;
- }
-
- s->arena = upb_Arena_New();
- s->bytes_loaded = 0;
-
- if (!upb_strtable_init(&s->syms, 32, s->arena) ||
- !upb_strtable_init(&s->files, 4, s->arena) ||
- !upb_inttable_init(&s->exts, s->arena)) {
- goto err;
- }
-
- s->extreg = upb_ExtensionRegistry_New(s->arena);
- if (!s->extreg) goto err;
- return s;
-
-err:
- upb_Arena_Free(s->arena);
- upb_gfree(s);
- return NULL;
-}
-
-static const void* symtab_lookup(const upb_DefPool* s, const char* sym,
- upb_deftype_t type) {
- upb_value v;
- return upb_strtable_lookup(&s->syms, sym, &v) ? unpack_def(v, type) : NULL;
-}
-
-static const void* symtab_lookup2(const upb_DefPool* s, const char* sym,
- size_t size, upb_deftype_t type) {
- upb_value v;
- return upb_strtable_lookup2(&s->syms, sym, size, &v) ? unpack_def(v, type)
- : NULL;
-}
-
-const upb_MessageDef* upb_DefPool_FindMessageByName(const upb_DefPool* s,
- const char* sym) {
- return symtab_lookup(s, sym, UPB_DEFTYPE_MSG);
-}
-
-const upb_MessageDef* upb_DefPool_FindMessageByNameWithSize(
- const upb_DefPool* s, const char* sym, size_t len) {
- return symtab_lookup2(s, sym, len, UPB_DEFTYPE_MSG);
-}
-
-const upb_EnumDef* upb_DefPool_FindEnumByName(const upb_DefPool* s,
- const char* sym) {
- return symtab_lookup(s, sym, UPB_DEFTYPE_ENUM);
-}
-
-const upb_EnumValueDef* upb_DefPool_FindEnumByNameval(const upb_DefPool* s,
- const char* sym) {
- return symtab_lookup(s, sym, UPB_DEFTYPE_ENUMVAL);
-}
-
-const upb_FileDef* upb_DefPool_FindFileByName(const upb_DefPool* s,
- const char* name) {
- upb_value v;
- return upb_strtable_lookup(&s->files, name, &v)
- ? unpack_def(v, UPB_DEFTYPE_FILE)
- : NULL;
-}
-
-const upb_FileDef* upb_DefPool_FindFileByNameWithSize(const upb_DefPool* s,
- const char* name,
- size_t len) {
- upb_value v;
- return upb_strtable_lookup2(&s->files, name, len, &v)
- ? unpack_def(v, UPB_DEFTYPE_FILE)
- : NULL;
-}
-
-const upb_FieldDef* upb_DefPool_FindExtensionByNameWithSize(
- const upb_DefPool* s, const char* name, size_t size) {
- upb_value v;
- if (!upb_strtable_lookup2(&s->syms, name, size, &v)) return NULL;
-
- switch (deftype(v)) {
- case UPB_DEFTYPE_FIELD:
- return unpack_def(v, UPB_DEFTYPE_FIELD);
- case UPB_DEFTYPE_MSG: {
- const upb_MessageDef* m = unpack_def(v, UPB_DEFTYPE_MSG);
- return m->in_message_set ? &m->nested_exts[0] : NULL;
- }
- default:
- break;
- }
-
- return NULL;
-}
-
-const upb_FieldDef* upb_DefPool_FindExtensionByName(const upb_DefPool* s,
- const char* sym) {
- return upb_DefPool_FindExtensionByNameWithSize(s, sym, strlen(sym));
-}
-
-const upb_ServiceDef* upb_DefPool_FindServiceByName(const upb_DefPool* s,
- const char* name) {
- return symtab_lookup(s, name, UPB_DEFTYPE_SERVICE);
-}
-
-const upb_ServiceDef* upb_DefPool_FindServiceByNameWithSize(
- const upb_DefPool* s, const char* name, size_t size) {
- return symtab_lookup2(s, name, size, UPB_DEFTYPE_SERVICE);
-}
-
-const upb_FileDef* upb_DefPool_FindFileContainingSymbol(const upb_DefPool* s,
- const char* name) {
- upb_value v;
- // TODO(haberman): non-extension fields and oneofs.
- if (upb_strtable_lookup(&s->syms, name, &v)) {
- switch (deftype(v)) {
- case UPB_DEFTYPE_EXT: {
- const upb_FieldDef* f = unpack_def(v, UPB_DEFTYPE_EXT);
- return upb_FieldDef_File(f);
- }
- case UPB_DEFTYPE_MSG: {
- const upb_MessageDef* m = unpack_def(v, UPB_DEFTYPE_MSG);
- return upb_MessageDef_File(m);
- }
- case UPB_DEFTYPE_ENUM: {
- const upb_EnumDef* e = unpack_def(v, UPB_DEFTYPE_ENUM);
- return upb_EnumDef_File(e);
- }
- case UPB_DEFTYPE_ENUMVAL: {
- const upb_EnumValueDef* ev = unpack_def(v, UPB_DEFTYPE_ENUMVAL);
- return upb_EnumDef_File(upb_EnumValueDef_Enum(ev));
- }
- case UPB_DEFTYPE_SERVICE: {
- const upb_ServiceDef* service = unpack_def(v, UPB_DEFTYPE_SERVICE);
- return upb_ServiceDef_File(service);
- }
- default:
- UPB_UNREACHABLE();
- }
- }
-
- const char* last_dot = strrchr(name, '.');
- if (last_dot) {
- const upb_MessageDef* parent =
- upb_DefPool_FindMessageByNameWithSize(s, name, last_dot - name);
- if (parent) {
- const char* shortname = last_dot + 1;
- if (upb_MessageDef_FindByNameWithSize(parent, shortname,
- strlen(shortname), NULL, NULL)) {
- return upb_MessageDef_File(parent);
- }
- }
- }
-
- return NULL;
-}
-
-/* Code to build defs from descriptor protos. *********************************/
-
-/* There is a question of how much validation to do here. It will be difficult
- * to perfectly match the amount of validation performed by proto2. But since
- * this code is used to directly build defs from Ruby (for example) we do need
- * to validate important constraints like uniqueness of names and numbers. */
-
-#define CHK_OOM(x) \
- if (!(x)) { \
- symtab_oomerr(ctx); \
- }
-
-typedef struct {
- upb_DefPool* symtab;
- upb_FileDef* file; /* File we are building. */
- upb_Arena* arena; /* Allocate defs here. */
- upb_Arena* tmp_arena; /* For temporary allocations. */
- const upb_MiniTable_File* layout; /* NULL if we should build layouts. */
- int enum_count; /* Count of enums built so far. */
- int msg_count; /* Count of messages built so far. */
- int ext_count; /* Count of extensions built so far. */
- upb_Status* status; /* Record errors here. */
- jmp_buf err; /* longjmp() on error. */
-} symtab_addctx;
-
-UPB_NORETURN UPB_NOINLINE UPB_PRINTF(2, 3) static void symtab_errf(
- symtab_addctx* ctx, const char* fmt, ...) {
- va_list argp;
- va_start(argp, fmt);
- upb_Status_VSetErrorFormat(ctx->status, fmt, argp);
- va_end(argp);
- UPB_LONGJMP(ctx->err, 1);
-}
-
-UPB_NORETURN UPB_NOINLINE static void symtab_oomerr(symtab_addctx* ctx) {
- upb_Status_setoom(ctx->status);
- UPB_LONGJMP(ctx->err, 1);
-}
-
-void* symtab_alloc(symtab_addctx* ctx, size_t bytes) {
- if (bytes == 0) return NULL;
- void* ret = upb_Arena_Malloc(ctx->arena, bytes);
- if (!ret) symtab_oomerr(ctx);
- return ret;
-}
-
-// We want to copy the options verbatim into the destination options proto.
-// We use serialize+parse as our deep copy.
-#define SET_OPTIONS(target, desc_type, options_type, proto) \
- if (google_protobuf_##desc_type##_has_options(proto)) { \
- size_t size; \
- char* pb = google_protobuf_##options_type##_serialize( \
- google_protobuf_##desc_type##_options(proto), ctx->tmp_arena, &size); \
- CHK_OOM(pb); \
- target = google_protobuf_##options_type##_parse(pb, size, ctx->arena); \
- CHK_OOM(target); \
- } else { \
- target = (const google_protobuf_##options_type*)opt_default; \
- }
-
-static void check_ident(symtab_addctx* ctx, upb_StringView name, bool full) {
- const char* str = name.data;
- size_t len = name.size;
- bool start = true;
- size_t i;
- for (i = 0; i < len; i++) {
- char c = str[i];
- if (c == '.') {
- if (start || !full) {
- symtab_errf(ctx, "invalid name: unexpected '.' (%.*s)", (int)len, str);
- }
- start = true;
- } else if (start) {
- if (!upb_isletter(c)) {
- symtab_errf(
- ctx,
- "invalid name: path components must start with a letter (%.*s)",
- (int)len, str);
- }
- start = false;
- } else {
- if (!upb_isalphanum(c)) {
- symtab_errf(ctx, "invalid name: non-alphanumeric character (%.*s)",
- (int)len, str);
- }
- }
- }
- if (start) {
- symtab_errf(ctx, "invalid name: empty part (%.*s)", (int)len, str);
- }
-}
-
-static size_t div_round_up(size_t n, size_t d) { return (n + d - 1) / d; }
-
-static size_t upb_MessageValue_sizeof(upb_CType type) {
- switch (type) {
- case kUpb_CType_Double:
- case kUpb_CType_Int64:
- case kUpb_CType_UInt64:
- return 8;
- case kUpb_CType_Enum:
- case kUpb_CType_Int32:
- case kUpb_CType_UInt32:
- case kUpb_CType_Float:
- return 4;
- case kUpb_CType_Bool:
- return 1;
- case kUpb_CType_Message:
- return sizeof(void*);
- case kUpb_CType_Bytes:
- case kUpb_CType_String:
- return sizeof(upb_StringView);
- }
- UPB_UNREACHABLE();
-}
-
-static uint8_t upb_msg_fielddefsize(const upb_FieldDef* f) {
- if (upb_MessageDef_IsMapEntry(upb_FieldDef_ContainingType(f))) {
- upb_MapEntry ent;
- UPB_ASSERT(sizeof(ent.k) == sizeof(ent.v));
- return sizeof(ent.k);
- } else if (upb_FieldDef_IsRepeated(f)) {
- return sizeof(void*);
- } else {
- return upb_MessageValue_sizeof(upb_FieldDef_CType(f));
- }
-}
-
-static uint32_t upb_MiniTable_place(symtab_addctx* ctx, upb_MiniTable* l,
- size_t size, const upb_MessageDef* m) {
- size_t ofs = UPB_ALIGN_UP(l->size, size);
- size_t next = ofs + size;
-
- if (next > UINT16_MAX) {
- symtab_errf(ctx, "size of message %s exceeded max size of %zu bytes",
- upb_MessageDef_FullName(m), (size_t)UINT16_MAX);
- }
-
- l->size = next;
- return ofs;
-}
-
-static int field_number_cmp(const void* p1, const void* p2) {
- const upb_MiniTable_Field* f1 = p1;
- const upb_MiniTable_Field* f2 = p2;
- return f1->number - f2->number;
-}
-
-static void assign_layout_indices(const upb_MessageDef* m, upb_MiniTable* l,
- upb_MiniTable_Field* fields) {
- int i;
- int n = upb_MessageDef_numfields(m);
- int dense_below = 0;
- for (i = 0; i < n; i++) {
- upb_FieldDef* f =
- (upb_FieldDef*)upb_MessageDef_FindFieldByNumber(m, fields[i].number);
- UPB_ASSERT(f);
- f->layout_index = i;
- if (i < UINT8_MAX && fields[i].number == i + 1 &&
- (i == 0 || fields[i - 1].number == i)) {
- dense_below = i + 1;
- }
- }
- l->dense_below = dense_below;
-}
-
-static uint8_t map_descriptortype(const upb_FieldDef* f) {
- uint8_t type = upb_FieldDef_Type(f);
- /* See TableDescriptorType() in upbc/generator.cc for details and
- * rationale of these exceptions. */
- if (type == kUpb_FieldType_String && f->file->syntax == kUpb_Syntax_Proto2) {
- return kUpb_FieldType_Bytes;
- } else if (type == kUpb_FieldType_Enum &&
- (f->sub.enumdef->file->syntax == kUpb_Syntax_Proto3 ||
- UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3 ||
- // TODO(https://github.com/protocolbuffers/upb/issues/541):
- // fix map enum values to check for unknown enum values and put
- // them in the unknown field set.
- upb_MessageDef_IsMapEntry(upb_FieldDef_ContainingType(f)))) {
- return kUpb_FieldType_Int32;
- }
- return type;
-}
-
-static void fill_fieldlayout(upb_MiniTable_Field* field,
- const upb_FieldDef* f) {
- field->number = upb_FieldDef_Number(f);
- field->descriptortype = map_descriptortype(f);
-
- if (upb_FieldDef_IsMap(f)) {
- field->mode =
- kUpb_FieldMode_Map | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift);
- } else if (upb_FieldDef_IsRepeated(f)) {
- field->mode =
- kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift);
- } else {
- /* Maps descriptor type -> elem_size_lg2. */
- static const uint8_t sizes[] = {
- -1, /* invalid descriptor type */
- kUpb_FieldRep_8Byte, /* DOUBLE */
- kUpb_FieldRep_4Byte, /* FLOAT */
- kUpb_FieldRep_8Byte, /* INT64 */
- kUpb_FieldRep_8Byte, /* UINT64 */
- kUpb_FieldRep_4Byte, /* INT32 */
- kUpb_FieldRep_8Byte, /* FIXED64 */
- kUpb_FieldRep_4Byte, /* FIXED32 */
- kUpb_FieldRep_1Byte, /* BOOL */
- kUpb_FieldRep_StringView, /* STRING */
- kUpb_FieldRep_Pointer, /* GROUP */
- kUpb_FieldRep_Pointer, /* MESSAGE */
- kUpb_FieldRep_StringView, /* BYTES */
- kUpb_FieldRep_4Byte, /* UINT32 */
- kUpb_FieldRep_4Byte, /* ENUM */
- kUpb_FieldRep_4Byte, /* SFIXED32 */
- kUpb_FieldRep_8Byte, /* SFIXED64 */
- kUpb_FieldRep_4Byte, /* SINT32 */
- kUpb_FieldRep_8Byte, /* SINT64 */
- };
- field->mode = kUpb_FieldMode_Scalar |
- (sizes[field->descriptortype] << kUpb_FieldRep_Shift);
- }
-
- if (upb_FieldDef_IsPacked(f)) {
- field->mode |= kUpb_LabelFlags_IsPacked;
- }
-
- if (upb_FieldDef_IsExtension(f)) {
- field->mode |= kUpb_LabelFlags_IsExtension;
- }
-}
-
-/* This function is the dynamic equivalent of message_layout.{cc,h} in upbc.
- * It computes a dynamic layout for all of the fields in |m|. */
-static void make_layout(symtab_addctx* ctx, const upb_MessageDef* m) {
- upb_MiniTable* l = (upb_MiniTable*)m->layout;
- size_t field_count = upb_MessageDef_numfields(m);
- size_t sublayout_count = 0;
- upb_MiniTable_Sub* subs;
- upb_MiniTable_Field* fields;
-
- memset(l, 0, sizeof(*l) + sizeof(_upb_FastTable_Entry));
-
- /* Count sub-messages. */
- for (size_t i = 0; i < field_count; i++) {
- const upb_FieldDef* f = &m->fields[i];
- if (upb_FieldDef_IsSubMessage(f)) {
- sublayout_count++;
- }
- if (upb_FieldDef_CType(f) == kUpb_CType_Enum &&
- f->sub.enumdef->file->syntax == kUpb_Syntax_Proto2) {
- sublayout_count++;
- }
- }
-
- fields = symtab_alloc(ctx, field_count * sizeof(*fields));
- subs = symtab_alloc(ctx, sublayout_count * sizeof(*subs));
-
- l->field_count = upb_MessageDef_numfields(m);
- l->fields = fields;
- l->subs = subs;
- l->table_mask = 0;
- l->required_count = 0;
-
- if (upb_MessageDef_ExtensionRangeCount(m) > 0) {
- if (google_protobuf_MessageOptions_message_set_wire_format(m->opts)) {
- l->ext = kUpb_ExtMode_IsMessageSet;
- } else {
- l->ext = kUpb_ExtMode_Extendable;
- }
- } else {
- l->ext = kUpb_ExtMode_NonExtendable;
- }
-
- /* TODO(haberman): initialize fast tables so that reflection-based parsing
- * can get the same speeds as linked-in types. */
- l->fasttable[0].field_parser = &fastdecode_generic;
- l->fasttable[0].field_data = 0;
-
- if (upb_MessageDef_IsMapEntry(m)) {
- /* TODO(haberman): refactor this method so this special case is more
- * elegant. */
- const upb_FieldDef* key = upb_MessageDef_FindFieldByNumber(m, 1);
- const upb_FieldDef* val = upb_MessageDef_FindFieldByNumber(m, 2);
- fields[0].number = 1;
- fields[1].number = 2;
- fields[0].mode = kUpb_FieldMode_Scalar;
- fields[1].mode = kUpb_FieldMode_Scalar;
- fields[0].presence = 0;
- fields[1].presence = 0;
- fields[0].descriptortype = map_descriptortype(key);
- fields[1].descriptortype = map_descriptortype(val);
- fields[0].offset = 0;
- fields[1].offset = sizeof(upb_StringView);
- fields[1].submsg_index = 0;
-
- if (upb_FieldDef_CType(val) == kUpb_CType_Message) {
- subs[0].submsg = upb_FieldDef_MessageSubDef(val)->layout;
- }
-
- upb_FieldDef* fielddefs = (upb_FieldDef*)&m->fields[0];
- UPB_ASSERT(fielddefs[0].number_ == 1);
- UPB_ASSERT(fielddefs[1].number_ == 2);
- fielddefs[0].layout_index = 0;
- fielddefs[1].layout_index = 1;
-
- l->field_count = 2;
- l->size = 2 * sizeof(upb_StringView);
- l->size = UPB_ALIGN_UP(l->size, 8);
- l->dense_below = 2;
- return;
- }
-
- /* Allocate data offsets in three stages:
- *
- * 1. hasbits.
- * 2. regular fields.
- * 3. oneof fields.
- *
- * OPT: There is a lot of room for optimization here to minimize the size.
- */
-
- /* Assign hasbits for required fields first. */
- size_t hasbit = 0;
-
- for (int i = 0; i < m->field_count; i++) {
- const upb_FieldDef* f = &m->fields[i];
- upb_MiniTable_Field* field = &fields[upb_FieldDef_Index(f)];
- if (upb_FieldDef_Label(f) == kUpb_Label_Required) {
- field->presence = ++hasbit;
- if (hasbit >= 63) {
- symtab_errf(ctx, "Message with >=63 required fields: %s",
- upb_MessageDef_FullName(m));
- }
- l->required_count++;
- }
- }
-
- /* Allocate hasbits and set basic field attributes. */
- sublayout_count = 0;
- for (int i = 0; i < m->field_count; i++) {
- const upb_FieldDef* f = &m->fields[i];
- upb_MiniTable_Field* field = &fields[upb_FieldDef_Index(f)];
-
- fill_fieldlayout(field, f);
-
- if (field->descriptortype == kUpb_FieldType_Message ||
- field->descriptortype == kUpb_FieldType_Group) {
- field->submsg_index = sublayout_count++;
- subs[field->submsg_index].submsg = upb_FieldDef_MessageSubDef(f)->layout;
- } else if (field->descriptortype == kUpb_FieldType_Enum) {
- field->submsg_index = sublayout_count++;
- subs[field->submsg_index].subenum = upb_FieldDef_EnumSubDef(f)->layout;
- UPB_ASSERT(subs[field->submsg_index].subenum);
- }
-
- if (upb_FieldDef_Label(f) == kUpb_Label_Required) {
- /* Hasbit was already assigned. */
- } else if (upb_FieldDef_HasPresence(f) &&
- !upb_FieldDef_RealContainingOneof(f)) {
- /* We don't use hasbit 0, so that 0 can indicate "no presence" in the
- * table. This wastes one hasbit, but we don't worry about it for now. */
- field->presence = ++hasbit;
- } else {
- field->presence = 0;
- }
- }
-
- /* Account for space used by hasbits. */
- l->size = hasbit ? div_round_up(hasbit + 1, 8) : 0;
-
- /* Allocate non-oneof fields. */
- for (int i = 0; i < m->field_count; i++) {
- const upb_FieldDef* f = &m->fields[i];
- size_t field_size = upb_msg_fielddefsize(f);
- size_t index = upb_FieldDef_Index(f);
-
- if (upb_FieldDef_RealContainingOneof(f)) {
- /* Oneofs are handled separately below. */
- continue;
- }
-
- fields[index].offset = upb_MiniTable_place(ctx, l, field_size, m);
- }
-
- /* Allocate oneof fields. Each oneof field consists of a uint32 for the case
- * and space for the actual data. */
- for (int i = 0; i < m->oneof_count; i++) {
- const upb_OneofDef* o = &m->oneofs[i];
- size_t case_size = sizeof(uint32_t); /* Could potentially optimize this. */
- size_t field_size = 0;
- uint32_t case_offset;
- uint32_t data_offset;
-
- if (upb_OneofDef_IsSynthetic(o)) continue;
-
- if (o->field_count == 0) {
- symtab_errf(ctx, "Oneof must have at least one field (%s)", o->full_name);
- }
-
- /* Calculate field size: the max of all field sizes. */
- for (int j = 0; j < o->field_count; j++) {
- const upb_FieldDef* f = o->fields[j];
- field_size = UPB_MAX(field_size, upb_msg_fielddefsize(f));
- }
-
- /* Align and allocate case offset. */
- case_offset = upb_MiniTable_place(ctx, l, case_size, m);
- data_offset = upb_MiniTable_place(ctx, l, field_size, m);
-
- for (int i = 0; i < o->field_count; i++) {
- const upb_FieldDef* f = o->fields[i];
- fields[upb_FieldDef_Index(f)].offset = data_offset;
- fields[upb_FieldDef_Index(f)].presence = ~case_offset;
- }
- }
-
- /* Size of the entire structure should be a multiple of its greatest
- * alignment. TODO: track overall alignment for real? */
- l->size = UPB_ALIGN_UP(l->size, 8);
-
- /* Sort fields by number. */
- if (fields) {
- qsort(fields, upb_MessageDef_numfields(m), sizeof(*fields),
- field_number_cmp);
- }
- assign_layout_indices(m, l, fields);
-}
-
-static char* strviewdup(symtab_addctx* ctx, upb_StringView view) {
- char* ret = upb_strdup2(view.data, view.size, ctx->arena);
- CHK_OOM(ret);
- return ret;
-}
-
-static bool streql2(const char* a, size_t n, const char* b) {
- return n == strlen(b) && memcmp(a, b, n) == 0;
-}
-
-static bool streql_view(upb_StringView view, const char* b) {
- return streql2(view.data, view.size, b);
-}
-
-static const char* makefullname(symtab_addctx* ctx, const char* prefix,
- upb_StringView name) {
- if (prefix) {
- /* ret = prefix + '.' + name; */
- size_t n = strlen(prefix);
- char* ret = symtab_alloc(ctx, n + name.size + 2);
- strcpy(ret, prefix);
- ret[n] = '.';
- memcpy(&ret[n + 1], name.data, name.size);
- ret[n + 1 + name.size] = '\0';
- return ret;
- } else {
- return strviewdup(ctx, name);
- }
-}
-
-static void finalize_oneofs(symtab_addctx* ctx, upb_MessageDef* m) {
- int i;
- int synthetic_count = 0;
- upb_OneofDef* mutable_oneofs = (upb_OneofDef*)m->oneofs;
-
- for (i = 0; i < m->oneof_count; i++) {
- upb_OneofDef* o = &mutable_oneofs[i];
-
- if (o->synthetic && o->field_count != 1) {
- symtab_errf(ctx, "Synthetic oneofs must have one field, not %d: %s",
- o->field_count, upb_OneofDef_Name(o));
- }
-
- if (o->synthetic) {
- synthetic_count++;
- } else if (synthetic_count != 0) {
- symtab_errf(ctx, "Synthetic oneofs must be after all other oneofs: %s",
- upb_OneofDef_Name(o));
- }
-
- o->fields = symtab_alloc(ctx, sizeof(upb_FieldDef*) * o->field_count);
- o->field_count = 0;
- }
-
- for (i = 0; i < m->field_count; i++) {
- const upb_FieldDef* f = &m->fields[i];
- upb_OneofDef* o = (upb_OneofDef*)upb_FieldDef_ContainingOneof(f);
- if (o) {
- o->fields[o->field_count++] = f;
- }
- }
-
- m->real_oneof_count = m->oneof_count - synthetic_count;
-}
-
-size_t getjsonname(const char* name, char* buf, size_t len) {
- size_t src, dst = 0;
- bool ucase_next = false;
-
-#define WRITE(byte) \
- ++dst; \
- if (dst < len) \
- buf[dst - 1] = byte; \
- else if (dst == len) \
- buf[dst - 1] = '\0'
-
- if (!name) {
- WRITE('\0');
- return 0;
- }
-
- /* Implement the transformation as described in the spec:
- * 1. upper case all letters after an underscore.
- * 2. remove all underscores.
- */
- for (src = 0; name[src]; src++) {
- if (name[src] == '_') {
- ucase_next = true;
- continue;
- }
-
- if (ucase_next) {
- WRITE(toupper(name[src]));
- ucase_next = false;
- } else {
- WRITE(name[src]);
- }
- }
-
- WRITE('\0');
- return dst;
-
-#undef WRITE
-}
-
-static char* makejsonname(symtab_addctx* ctx, const char* name) {
- size_t size = getjsonname(name, NULL, 0);
- char* json_name = symtab_alloc(ctx, size);
- getjsonname(name, json_name, size);
- return json_name;
-}
-
-/* Adds a symbol |v| to the symtab, which must be a def pointer previously
- * packed with pack_def(). The def's pointer to upb_FileDef* must be set before
- * adding, so we know which entries to remove if building this file fails. */
-static void symtab_add(symtab_addctx* ctx, const char* name, upb_value v) {
- // TODO: table should support an operation "tryinsert" to avoid the double
- // lookup.
- if (upb_strtable_lookup(&ctx->symtab->syms, name, NULL)) {
- symtab_errf(ctx, "duplicate symbol '%s'", name);
- }
- size_t len = strlen(name);
- CHK_OOM(upb_strtable_insert(&ctx->symtab->syms, name, len, v,
- ctx->symtab->arena));
-}
-
-static bool remove_component(char* base, size_t* len) {
- if (*len == 0) return false;
-
- for (size_t i = *len - 1; i > 0; i--) {
- if (base[i] == '.') {
- *len = i;
- return true;
- }
- }
-
- *len = 0;
- return true;
-}
-
-/* Given a symbol and the base symbol inside which it is defined, find the
- * symbol's definition in t. */
-static const void* symtab_resolveany(symtab_addctx* ctx,
- const char* from_name_dbg,
- const char* base, upb_StringView sym,
- upb_deftype_t* type) {
- const upb_strtable* t = &ctx->symtab->syms;
- if (sym.size == 0) goto notfound;
- upb_value v;
- if (sym.data[0] == '.') {
- /* Symbols starting with '.' are absolute, so we do a single lookup.
- * Slice to omit the leading '.' */
- if (!upb_strtable_lookup2(t, sym.data + 1, sym.size - 1, &v)) {
- goto notfound;
- }
- } else {
- /* Remove components from base until we find an entry or run out. */
- size_t baselen = base ? strlen(base) : 0;
- char* tmp = malloc(sym.size + baselen + 1);
- while (1) {
- char* p = tmp;
- if (baselen) {
- memcpy(p, base, baselen);
- p[baselen] = '.';
- p += baselen + 1;
- }
- memcpy(p, sym.data, sym.size);
- p += sym.size;
- if (upb_strtable_lookup2(t, tmp, p - tmp, &v)) {
- break;
- }
- if (!remove_component(tmp, &baselen)) {
- free(tmp);
- goto notfound;
- }
- }
- free(tmp);
- }
-
- *type = deftype(v);
- return unpack_def(v, *type);
-
-notfound:
- symtab_errf(ctx, "couldn't resolve name '" UPB_STRINGVIEW_FORMAT "'",
- UPB_STRINGVIEW_ARGS(sym));
-}
-
-static const void* symtab_resolve(symtab_addctx* ctx, const char* from_name_dbg,
- const char* base, upb_StringView sym,
- upb_deftype_t type) {
- upb_deftype_t found_type;
- const void* ret =
- symtab_resolveany(ctx, from_name_dbg, base, sym, &found_type);
- if (ret && found_type != type) {
- symtab_errf(ctx,
- "type mismatch when resolving %s: couldn't find "
- "name " UPB_STRINGVIEW_FORMAT " with type=%d",
- from_name_dbg, UPB_STRINGVIEW_ARGS(sym), (int)type);
- }
- return ret;
-}
-
-static void create_oneofdef(
- symtab_addctx* ctx, upb_MessageDef* m,
- const google_protobuf_OneofDescriptorProto* oneof_proto,
- const upb_OneofDef* _o) {
- upb_OneofDef* o = (upb_OneofDef*)_o;
- upb_StringView name = google_protobuf_OneofDescriptorProto_name(oneof_proto);
- upb_value v;
-
- o->parent = m;
- o->full_name = makefullname(ctx, m->full_name, name);
- o->field_count = 0;
- o->synthetic = false;
-
- SET_OPTIONS(o->opts, OneofDescriptorProto, OneofOptions, oneof_proto);
-
- upb_value existing_v;
- if (upb_strtable_lookup2(&m->ntof, name.data, name.size, &existing_v)) {
- symtab_errf(ctx, "duplicate oneof name (%s)", o->full_name);
- }
-
- v = pack_def(o, UPB_DEFTYPE_ONEOF);
- CHK_OOM(upb_strtable_insert(&m->ntof, name.data, name.size, v, ctx->arena));
-
- CHK_OOM(upb_inttable_init(&o->itof, ctx->arena));
- CHK_OOM(upb_strtable_init(&o->ntof, 4, ctx->arena));
-}
-
-static str_t* newstr(symtab_addctx* ctx, const char* data, size_t len) {
- str_t* ret = symtab_alloc(ctx, sizeof(*ret) + len);
- CHK_OOM(ret);
- ret->len = len;
- if (len) memcpy(ret->str, data, len);
- ret->str[len] = '\0';
- return ret;
-}
-
-static bool upb_DefPool_TryGetChar(const char** src, const char* end,
- char* ch) {
- if (*src == end) return false;
- *ch = **src;
- *src += 1;
- return true;
-}
-
-static char upb_DefPool_TryGetHexDigit(symtab_addctx* ctx,
- const upb_FieldDef* f, const char** src,
- const char* end) {
- char ch;
- if (!upb_DefPool_TryGetChar(src, end, &ch)) return -1;
- if ('0' <= ch && ch <= '9') {
- return ch - '0';
- }
- ch = upb_ascii_lower(ch);
- if ('a' <= ch && ch <= 'f') {
- return ch - 'a' + 0xa;
- }
- *src -= 1; // Char wasn't actually a hex digit.
- return -1;
-}
-
-static char upb_DefPool_ParseHexEscape(symtab_addctx* ctx,
- const upb_FieldDef* f, const char** src,
- const char* end) {
- char hex_digit = upb_DefPool_TryGetHexDigit(ctx, f, src, end);
- if (hex_digit < 0) {
- symtab_errf(ctx,
- "\\x cannot be followed by non-hex digit in field '%s' default",
- upb_FieldDef_FullName(f));
- return 0;
- }
- unsigned int ret = hex_digit;
- while ((hex_digit = upb_DefPool_TryGetHexDigit(ctx, f, src, end)) >= 0) {
- ret = (ret << 4) | hex_digit;
- }
- if (ret > 0xff) {
- symtab_errf(ctx, "Value of hex escape in field %s exceeds 8 bits",
- upb_FieldDef_FullName(f));
- return 0;
- }
- return ret;
-}
-
-char upb_DefPool_TryGetOctalDigit(const char** src, const char* end) {
- char ch;
- if (!upb_DefPool_TryGetChar(src, end, &ch)) return -1;
- if ('0' <= ch && ch <= '7') {
- return ch - '0';
- }
- *src -= 1; // Char wasn't actually an octal digit.
- return -1;
-}
-
-static char upb_DefPool_ParseOctalEscape(symtab_addctx* ctx,
- const upb_FieldDef* f,
- const char** src, const char* end) {
- char ch = 0;
- for (int i = 0; i < 3; i++) {
- char digit;
- if ((digit = upb_DefPool_TryGetOctalDigit(src, end)) >= 0) {
- ch = (ch << 3) | digit;
- }
- }
- return ch;
-}
-
-static char upb_DefPool_ParseEscape(symtab_addctx* ctx, const upb_FieldDef* f,
- const char** src, const char* end) {
- char ch;
- if (!upb_DefPool_TryGetChar(src, end, &ch)) {
- symtab_errf(ctx, "unterminated escape sequence in field %s",
- upb_FieldDef_FullName(f));
- return 0;
- }
- switch (ch) {
- case 'a':
- return '\a';
- case 'b':
- return '\b';
- case 'f':
- return '\f';
- case 'n':
- return '\n';
- case 'r':
- return '\r';
- case 't':
- return '\t';
- case 'v':
- return '\v';
- case '\\':
- return '\\';
- case '\'':
- return '\'';
- case '\"':
- return '\"';
- case '?':
- return '\?';
- case 'x':
- case 'X':
- return upb_DefPool_ParseHexEscape(ctx, f, src, end);
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- *src -= 1;
- return upb_DefPool_ParseOctalEscape(ctx, f, src, end);
- }
- symtab_errf(ctx, "Unknown escape sequence: \\%c", ch);
-}
-
-static str_t* unescape(symtab_addctx* ctx, const upb_FieldDef* f,
- const char* data, size_t len) {
- // Size here is an upper bound; escape sequences could ultimately shrink it.
- str_t* ret = symtab_alloc(ctx, sizeof(*ret) + len);
- char* dst = &ret->str[0];
- const char* src = data;
- const char* end = data + len;
-
- while (src < end) {
- if (*src == '\\') {
- src++;
- *dst++ = upb_DefPool_ParseEscape(ctx, f, &src, end);
- } else {
- *dst++ = *src++;
- }
- }
-
- ret->len = dst - &ret->str[0];
- return ret;
-}
-
-static void parse_default(symtab_addctx* ctx, const char* str, size_t len,
- upb_FieldDef* f) {
- char* end;
- char nullz[64];
- errno = 0;
-
- switch (upb_FieldDef_CType(f)) {
- case kUpb_CType_Int32:
- case kUpb_CType_Int64:
- case kUpb_CType_UInt32:
- case kUpb_CType_UInt64:
- case kUpb_CType_Double:
- case kUpb_CType_Float:
- /* Standard C number parsing functions expect null-terminated strings. */
- if (len >= sizeof(nullz) - 1) {
- symtab_errf(ctx, "Default too long: %.*s", (int)len, str);
- }
- memcpy(nullz, str, len);
- nullz[len] = '\0';
- str = nullz;
- break;
- default:
- break;
- }
-
- switch (upb_FieldDef_CType(f)) {
- case kUpb_CType_Int32: {
- long val = strtol(str, &end, 0);
- if (val > INT32_MAX || val < INT32_MIN || errno == ERANGE || *end) {
- goto invalid;
- }
- f->defaultval.sint = val;
- break;
- }
- case kUpb_CType_Enum: {
- const upb_EnumDef* e = f->sub.enumdef;
- const upb_EnumValueDef* ev =
- upb_EnumDef_FindValueByNameWithSize(e, str, len);
- if (!ev) {
- goto invalid;
- }
- f->defaultval.sint = ev->number;
- break;
- }
- case kUpb_CType_Int64: {
- long long val = strtoll(str, &end, 0);
- if (val > INT64_MAX || val < INT64_MIN || errno == ERANGE || *end) {
- goto invalid;
- }
- f->defaultval.sint = val;
- break;
- }
- case kUpb_CType_UInt32: {
- unsigned long val = strtoul(str, &end, 0);
- if (val > UINT32_MAX || errno == ERANGE || *end) {
- goto invalid;
- }
- f->defaultval.uint = val;
- break;
- }
- case kUpb_CType_UInt64: {
- unsigned long long val = strtoull(str, &end, 0);
- if (val > UINT64_MAX || errno == ERANGE || *end) {
- goto invalid;
- }
- f->defaultval.uint = val;
- break;
- }
- case kUpb_CType_Double: {
- double val = strtod(str, &end);
- if (errno == ERANGE || *end) {
- goto invalid;
- }
- f->defaultval.dbl = val;
- break;
- }
- case kUpb_CType_Float: {
- float val = strtof(str, &end);
- if (errno == ERANGE || *end) {
- goto invalid;
- }
- f->defaultval.flt = val;
- break;
- }
- case kUpb_CType_Bool: {
- if (streql2(str, len, "false")) {
- f->defaultval.boolean = false;
- } else if (streql2(str, len, "true")) {
- f->defaultval.boolean = true;
- } else {
- goto invalid;
- }
- break;
- }
- case kUpb_CType_String:
- f->defaultval.str = newstr(ctx, str, len);
- break;
- case kUpb_CType_Bytes:
- f->defaultval.str = unescape(ctx, f, str, len);
- break;
- case kUpb_CType_Message:
- /* Should not have a default value. */
- symtab_errf(ctx, "Message should not have a default (%s)",
- upb_FieldDef_FullName(f));
- }
-
- return;
-
-invalid:
- symtab_errf(ctx, "Invalid default '%.*s' for field %s of type %d", (int)len,
- str, upb_FieldDef_FullName(f), (int)upb_FieldDef_Type(f));
-}
-
-static void set_default_default(symtab_addctx* ctx, upb_FieldDef* f) {
- switch (upb_FieldDef_CType(f)) {
- case kUpb_CType_Int32:
- case kUpb_CType_Int64:
- f->defaultval.sint = 0;
- break;
- case kUpb_CType_UInt64:
- case kUpb_CType_UInt32:
- f->defaultval.uint = 0;
- break;
- case kUpb_CType_Double:
- case kUpb_CType_Float:
- f->defaultval.dbl = 0;
- break;
- case kUpb_CType_String:
- case kUpb_CType_Bytes:
- f->defaultval.str = newstr(ctx, NULL, 0);
- break;
- case kUpb_CType_Bool:
- f->defaultval.boolean = false;
- break;
- case kUpb_CType_Enum:
- f->defaultval.sint = f->sub.enumdef->values[0].number;
- case kUpb_CType_Message:
- break;
- }
-}
-
-static void create_fielddef(
- symtab_addctx* ctx, const char* prefix, upb_MessageDef* m,
- const google_protobuf_FieldDescriptorProto* field_proto,
- const upb_FieldDef* _f, bool is_extension) {
- upb_FieldDef* f = (upb_FieldDef*)_f;
- upb_StringView name;
- const char* full_name;
- const char* json_name;
- const char* shortname;
- int32_t field_number;
-
- f->file = ctx->file; /* Must happen prior to symtab_add(). */
-
- if (!google_protobuf_FieldDescriptorProto_has_name(field_proto)) {
- symtab_errf(ctx, "field has no name");
- }
-
- name = google_protobuf_FieldDescriptorProto_name(field_proto);
- check_ident(ctx, name, false);
- full_name = makefullname(ctx, prefix, name);
- shortname = shortdefname(full_name);
-
- if (google_protobuf_FieldDescriptorProto_has_json_name(field_proto)) {
- json_name = strviewdup(
- ctx, google_protobuf_FieldDescriptorProto_json_name(field_proto));
- f->has_json_name_ = true;
- } else {
- json_name = makejsonname(ctx, shortname);
- f->has_json_name_ = false;
- }
-
- field_number = google_protobuf_FieldDescriptorProto_number(field_proto);
-
- f->full_name = full_name;
- f->json_name = json_name;
- f->label_ = (int)google_protobuf_FieldDescriptorProto_label(field_proto);
- f->number_ = field_number;
- f->scope.oneof = NULL;
- f->proto3_optional_ =
- google_protobuf_FieldDescriptorProto_proto3_optional(field_proto);
-
- bool has_type = google_protobuf_FieldDescriptorProto_has_type(field_proto);
- bool has_type_name =
- google_protobuf_FieldDescriptorProto_has_type_name(field_proto);
-
- f->type_ = (int)google_protobuf_FieldDescriptorProto_type(field_proto);
-
- if (has_type) {
- switch (f->type_) {
- case kUpb_FieldType_Message:
- case kUpb_FieldType_Group:
- case kUpb_FieldType_Enum:
- if (!has_type_name) {
- symtab_errf(ctx, "field of type %d requires type name (%s)",
- (int)f->type_, full_name);
- }
- break;
- default:
- if (has_type_name) {
- symtab_errf(ctx, "invalid type for field with type_name set (%s, %d)",
- full_name, (int)f->type_);
- }
- }
- } else if (has_type_name) {
- f->type_ =
- FIELD_TYPE_UNSPECIFIED; // We'll fill this in in resolve_fielddef().
- }
-
- if (!is_extension) {
- /* direct message field. */
- upb_value v, field_v, json_v, existing_v;
- size_t json_size;
-
- if (field_number <= 0 || field_number > kUpb_MaxFieldNumber) {
- symtab_errf(ctx, "invalid field number (%u)", field_number);
- }
-
- f->index_ = f - m->fields;
- f->msgdef = m;
- f->is_extension_ = false;
-
- field_v = pack_def(f, UPB_DEFTYPE_FIELD);
- json_v = pack_def(f, UPB_DEFTYPE_FIELD_JSONNAME);
- v = upb_value_constptr(f);
- json_size = strlen(json_name);
-
- if (upb_strtable_lookup(&m->ntof, shortname, &existing_v)) {
- symtab_errf(ctx, "duplicate field name (%s)", shortname);
- }
-
- CHK_OOM(upb_strtable_insert(&m->ntof, name.data, name.size, field_v,
- ctx->arena));
-
- if (strcmp(shortname, json_name) != 0) {
- if (upb_strtable_lookup(&m->ntof, json_name, &v)) {
- symtab_errf(ctx, "duplicate json_name (%s)", json_name);
- } else {
- CHK_OOM(upb_strtable_insert(&m->ntof, json_name, json_size, json_v,
- ctx->arena));
- }
- }
-
- if (upb_inttable_lookup(&m->itof, field_number, NULL)) {
- symtab_errf(ctx, "duplicate field number (%u)", field_number);
- }
-
- CHK_OOM(upb_inttable_insert(&m->itof, field_number, v, ctx->arena));
-
- if (ctx->layout) {
- const upb_MiniTable_Field* fields = m->layout->fields;
- int count = m->layout->field_count;
- bool found = false;
- for (int i = 0; i < count; i++) {
- if (fields[i].number == field_number) {
- f->layout_index = i;
- found = true;
- break;
- }
- }
- UPB_ASSERT(found);
- }
- } else {
- /* extension field. */
- f->is_extension_ = true;
- f->scope.extension_scope = m;
- symtab_add(ctx, full_name, pack_def(f, UPB_DEFTYPE_EXT));
- f->layout_index = ctx->ext_count++;
- if (ctx->layout) {
- UPB_ASSERT(ctx->file->ext_layouts[f->layout_index]->field.number ==
- field_number);
- }
- }
-
- if (f->type_ < kUpb_FieldType_Double || f->type_ > kUpb_FieldType_SInt64) {
- symtab_errf(ctx, "invalid type for field %s (%d)", f->full_name, f->type_);
- }
-
- if (f->label_ < kUpb_Label_Optional || f->label_ > kUpb_Label_Repeated) {
- symtab_errf(ctx, "invalid label for field %s (%d)", f->full_name,
- f->label_);
- }
-
- /* We can't resolve the subdef or (in the case of extensions) the containing
- * message yet, because it may not have been defined yet. We stash a pointer
- * to the field_proto until later when we can properly resolve it. */
- f->sub.unresolved = field_proto;
-
- if (f->label_ == kUpb_Label_Required &&
- f->file->syntax == kUpb_Syntax_Proto3) {
- symtab_errf(ctx, "proto3 fields cannot be required (%s)", f->full_name);
- }
-
- if (google_protobuf_FieldDescriptorProto_has_oneof_index(field_proto)) {
- int oneof_index =
- google_protobuf_FieldDescriptorProto_oneof_index(field_proto);
- upb_OneofDef* oneof;
- upb_value v = upb_value_constptr(f);
-
- if (upb_FieldDef_Label(f) != kUpb_Label_Optional) {
- symtab_errf(ctx, "fields in oneof must have OPTIONAL label (%s)",
- f->full_name);
- }
-
- if (!m) {
- symtab_errf(ctx, "oneof_index provided for extension field (%s)",
- f->full_name);
- }
-
- if (oneof_index >= m->oneof_count) {
- symtab_errf(ctx, "oneof_index out of range (%s)", f->full_name);
- }
-
- oneof = (upb_OneofDef*)&m->oneofs[oneof_index];
- f->scope.oneof = oneof;
-
- oneof->field_count++;
- if (f->proto3_optional_) {
- oneof->synthetic = true;
- }
- CHK_OOM(upb_inttable_insert(&oneof->itof, f->number_, v, ctx->arena));
- CHK_OOM(
- upb_strtable_insert(&oneof->ntof, name.data, name.size, v, ctx->arena));
- } else {
- if (f->proto3_optional_) {
- symtab_errf(ctx, "field with proto3_optional was not in a oneof (%s)",
- f->full_name);
- }
- }
-
- SET_OPTIONS(f->opts, FieldDescriptorProto, FieldOptions, field_proto);
-
- if (google_protobuf_FieldOptions_has_packed(f->opts)) {
- f->packed_ = google_protobuf_FieldOptions_packed(f->opts);
- } else {
- /* Repeated fields default to packed for proto3 only. */
- f->packed_ = upb_FieldDef_IsPrimitive(f) &&
- f->label_ == kUpb_Label_Repeated &&
- f->file->syntax == kUpb_Syntax_Proto3;
- }
-}
-
-static void create_service(
- symtab_addctx* ctx, const google_protobuf_ServiceDescriptorProto* svc_proto,
- const upb_ServiceDef* _s) {
- upb_ServiceDef* s = (upb_ServiceDef*)_s;
- upb_StringView name;
- const google_protobuf_MethodDescriptorProto* const* methods;
- size_t i, n;
-
- s->file = ctx->file; /* Must happen prior to symtab_add. */
-
- name = google_protobuf_ServiceDescriptorProto_name(svc_proto);
- check_ident(ctx, name, false);
- s->full_name = makefullname(ctx, ctx->file->package, name);
- symtab_add(ctx, s->full_name, pack_def(s, UPB_DEFTYPE_SERVICE));
-
- methods = google_protobuf_ServiceDescriptorProto_method(svc_proto, &n);
-
- s->method_count = n;
- s->methods = symtab_alloc(ctx, sizeof(*s->methods) * n);
-
- SET_OPTIONS(s->opts, ServiceDescriptorProto, ServiceOptions, svc_proto);
-
- for (i = 0; i < n; i++) {
- const google_protobuf_MethodDescriptorProto* method_proto = methods[i];
- upb_MethodDef* m = (upb_MethodDef*)&s->methods[i];
- upb_StringView name =
- google_protobuf_MethodDescriptorProto_name(method_proto);
-
- m->service = s;
- m->full_name = makefullname(ctx, s->full_name, name);
- m->index = i;
- m->client_streaming =
- google_protobuf_MethodDescriptorProto_client_streaming(method_proto);
- m->server_streaming =
- google_protobuf_MethodDescriptorProto_server_streaming(method_proto);
- m->input_type = symtab_resolve(
- ctx, m->full_name, m->full_name,
- google_protobuf_MethodDescriptorProto_input_type(method_proto),
- UPB_DEFTYPE_MSG);
- m->output_type = symtab_resolve(
- ctx, m->full_name, m->full_name,
- google_protobuf_MethodDescriptorProto_output_type(method_proto),
- UPB_DEFTYPE_MSG);
-
- SET_OPTIONS(m->opts, MethodDescriptorProto, MethodOptions, method_proto);
- }
-}
-
-static int count_bits_debug(uint64_t x) {
- // For assertions only, speed does not matter.
- int n = 0;
- while (x) {
- if (x & 1) n++;
- x >>= 1;
- }
- return n;
-}
-
-static int compare_int32(const void* a_ptr, const void* b_ptr) {
- int32_t a = *(int32_t*)a_ptr;
- int32_t b = *(int32_t*)b_ptr;
- return a < b ? -1 : (a == b ? 0 : 1);
-}
-
-upb_MiniTable_Enum* create_enumlayout(symtab_addctx* ctx,
- const upb_EnumDef* e) {
- int n = 0;
- uint64_t mask = 0;
-
- for (int i = 0; i < e->value_count; i++) {
- uint32_t val = (uint32_t)e->values[i].number;
- if (val < 64) {
- mask |= 1ULL << val;
- } else {
- n++;
- }
- }
-
- int32_t* values = symtab_alloc(ctx, sizeof(*values) * n);
-
- if (n) {
- int32_t* p = values;
-
- // Add values outside the bitmask range to the list, as described in the
- // comments for upb_MiniTable_Enum.
- for (int i = 0; i < e->value_count; i++) {
- int32_t val = e->values[i].number;
- if ((uint32_t)val >= 64) {
- *p++ = val;
- }
- }
- UPB_ASSERT(p == values + n);
- }
-
- // Enums can have duplicate values; we must sort+uniq them.
- if (values) qsort(values, n, sizeof(*values), &compare_int32);
-
- int dst = 0;
- for (int i = 0; i < n; dst++) {
- int32_t val = values[i];
- while (i < n && values[i] == val) i++; // Skip duplicates.
- values[dst] = val;
- }
- n = dst;
-
- UPB_ASSERT(upb_inttable_count(&e->iton) == n + count_bits_debug(mask));
-
- upb_MiniTable_Enum* layout = symtab_alloc(ctx, sizeof(*layout));
- layout->value_count = n;
- layout->mask = mask;
- layout->values = values;
-
- return layout;
-}
-
-static void create_enumvaldef(
- symtab_addctx* ctx, const char* prefix,
- const google_protobuf_EnumValueDescriptorProto* val_proto, upb_EnumDef* e,
- int i) {
- upb_EnumValueDef* val = (upb_EnumValueDef*)&e->values[i];
- upb_StringView name =
- google_protobuf_EnumValueDescriptorProto_name(val_proto);
- upb_value v = upb_value_constptr(val);
-
- val->parent = e; /* Must happen prior to symtab_add(). */
- val->full_name = makefullname(ctx, prefix, name);
- val->number = google_protobuf_EnumValueDescriptorProto_number(val_proto);
- symtab_add(ctx, val->full_name, pack_def(val, UPB_DEFTYPE_ENUMVAL));
-
- SET_OPTIONS(val->opts, EnumValueDescriptorProto, EnumValueOptions, val_proto);
-
- if (i == 0 && e->file->syntax == kUpb_Syntax_Proto3 && val->number != 0) {
- symtab_errf(ctx, "for proto3, the first enum value must be zero (%s)",
- e->full_name);
- }
-
- CHK_OOM(upb_strtable_insert(&e->ntoi, name.data, name.size, v, ctx->arena));
-
- // Multiple enumerators can have the same number, first one wins.
- if (!upb_inttable_lookup(&e->iton, val->number, NULL)) {
- CHK_OOM(upb_inttable_insert(&e->iton, val->number, v, ctx->arena));
- }
-}
-
-static void create_enumdef(
- symtab_addctx* ctx, const char* prefix,
- const google_protobuf_EnumDescriptorProto* enum_proto,
- const upb_MessageDef* containing_type, const upb_EnumDef* _e) {
- upb_EnumDef* e = (upb_EnumDef*)_e;
- ;
- const google_protobuf_EnumValueDescriptorProto* const* values;
- upb_StringView name;
- size_t i, n;
-
- e->file = ctx->file; /* Must happen prior to symtab_add() */
- e->containing_type = containing_type;
-
- name = google_protobuf_EnumDescriptorProto_name(enum_proto);
- check_ident(ctx, name, false);
-
- e->full_name = makefullname(ctx, prefix, name);
- symtab_add(ctx, e->full_name, pack_def(e, UPB_DEFTYPE_ENUM));
-
- values = google_protobuf_EnumDescriptorProto_value(enum_proto, &n);
- CHK_OOM(upb_strtable_init(&e->ntoi, n, ctx->arena));
- CHK_OOM(upb_inttable_init(&e->iton, ctx->arena));
-
- e->defaultval = 0;
- e->value_count = n;
- e->values = symtab_alloc(ctx, sizeof(*e->values) * n);
-
- if (n == 0) {
- symtab_errf(ctx, "enums must contain at least one value (%s)",
- e->full_name);
- }
-
- SET_OPTIONS(e->opts, EnumDescriptorProto, EnumOptions, enum_proto);
-
- for (i = 0; i < n; i++) {
- create_enumvaldef(ctx, prefix, values[i], e, i);
- }
-
- upb_inttable_compact(&e->iton, ctx->arena);
-
- if (e->file->syntax == kUpb_Syntax_Proto2) {
- if (ctx->layout) {
- UPB_ASSERT(ctx->enum_count < ctx->layout->enum_count);
- e->layout = ctx->layout->enums[ctx->enum_count++];
- UPB_ASSERT(upb_inttable_count(&e->iton) ==
- e->layout->value_count + count_bits_debug(e->layout->mask));
- } else {
- e->layout = create_enumlayout(ctx, e);
- }
- } else {
- e->layout = NULL;
- }
-}
-
-static void msgdef_create_nested(
- symtab_addctx* ctx, const google_protobuf_DescriptorProto* msg_proto,
- upb_MessageDef* m);
-
-static void create_msgdef(symtab_addctx* ctx, const char* prefix,
- const google_protobuf_DescriptorProto* msg_proto,
- const upb_MessageDef* containing_type,
- const upb_MessageDef* _m) {
- upb_MessageDef* m = (upb_MessageDef*)_m;
- const google_protobuf_OneofDescriptorProto* const* oneofs;
- const google_protobuf_FieldDescriptorProto* const* fields;
- const google_protobuf_DescriptorProto_ExtensionRange* const* ext_ranges;
- size_t i, n_oneof, n_field, n_ext_range;
- upb_StringView name;
-
- m->file = ctx->file; /* Must happen prior to symtab_add(). */
- m->containing_type = containing_type;
-
- name = google_protobuf_DescriptorProto_name(msg_proto);
- check_ident(ctx, name, false);
-
- m->full_name = makefullname(ctx, prefix, name);
- symtab_add(ctx, m->full_name, pack_def(m, UPB_DEFTYPE_MSG));
-
- oneofs = google_protobuf_DescriptorProto_oneof_decl(msg_proto, &n_oneof);
- fields = google_protobuf_DescriptorProto_field(msg_proto, &n_field);
- ext_ranges =
- google_protobuf_DescriptorProto_extension_range(msg_proto, &n_ext_range);
-
- CHK_OOM(upb_inttable_init(&m->itof, ctx->arena));
- CHK_OOM(upb_strtable_init(&m->ntof, n_oneof + n_field, ctx->arena));
-
- if (ctx->layout) {
- /* create_fielddef() below depends on this being set. */
- UPB_ASSERT(ctx->msg_count < ctx->layout->msg_count);
- m->layout = ctx->layout->msgs[ctx->msg_count++];
- UPB_ASSERT(n_field == m->layout->field_count);
- } else {
- /* Allocate now (to allow cross-linking), populate later. */
- m->layout =
- symtab_alloc(ctx, sizeof(*m->layout) + sizeof(_upb_FastTable_Entry));
- }
-
- SET_OPTIONS(m->opts, DescriptorProto, MessageOptions, msg_proto);
-
- m->oneof_count = n_oneof;
- m->oneofs = symtab_alloc(ctx, sizeof(*m->oneofs) * n_oneof);
- for (i = 0; i < n_oneof; i++) {
- create_oneofdef(ctx, m, oneofs[i], &m->oneofs[i]);
- }
-
- m->field_count = n_field;
- m->fields = symtab_alloc(ctx, sizeof(*m->fields) * n_field);
- for (i = 0; i < n_field; i++) {
- create_fielddef(ctx, m->full_name, m, fields[i], &m->fields[i],
- /* is_extension= */ false);
- }
-
- m->ext_range_count = n_ext_range;
- m->ext_ranges = symtab_alloc(ctx, sizeof(*m->ext_ranges) * n_ext_range);
- for (i = 0; i < n_ext_range; i++) {
- const google_protobuf_DescriptorProto_ExtensionRange* r = ext_ranges[i];
- upb_ExtensionRange* r_def = (upb_ExtensionRange*)&m->ext_ranges[i];
- int32_t start = google_protobuf_DescriptorProto_ExtensionRange_start(r);
- int32_t end = google_protobuf_DescriptorProto_ExtensionRange_end(r);
- int32_t max =
- google_protobuf_MessageOptions_message_set_wire_format(m->opts)
- ? INT32_MAX
- : kUpb_MaxFieldNumber + 1;
-
- // A full validation would also check that each range is disjoint, and that
- // none of the fields overlap with the extension ranges, but we are just
- // sanity checking here.
- if (start < 1 || end <= start || end > max) {
- symtab_errf(ctx, "Extension range (%d, %d) is invalid, message=%s\n",
- (int)start, (int)end, m->full_name);
- }
-
- r_def->start = start;
- r_def->end = end;
- SET_OPTIONS(r_def->opts, DescriptorProto_ExtensionRange,
- ExtensionRangeOptions, r);
- }
-
- finalize_oneofs(ctx, m);
- assign_msg_wellknowntype(m);
- upb_inttable_compact(&m->itof, ctx->arena);
- msgdef_create_nested(ctx, msg_proto, m);
-}
-
-static void msgdef_create_nested(
- symtab_addctx* ctx, const google_protobuf_DescriptorProto* msg_proto,
- upb_MessageDef* m) {
- size_t n;
-
- const google_protobuf_EnumDescriptorProto* const* enums =
- google_protobuf_DescriptorProto_enum_type(msg_proto, &n);
- m->nested_enum_count = n;
- m->nested_enums = symtab_alloc(ctx, sizeof(*m->nested_enums) * n);
- for (size_t i = 0; i < n; i++) {
- m->nested_enum_count = i + 1;
- create_enumdef(ctx, m->full_name, enums[i], m, &m->nested_enums[i]);
- }
-
- const google_protobuf_FieldDescriptorProto* const* exts =
- google_protobuf_DescriptorProto_extension(msg_proto, &n);
- m->nested_ext_count = n;
- m->nested_exts = symtab_alloc(ctx, sizeof(*m->nested_exts) * n);
- for (size_t i = 0; i < n; i++) {
- create_fielddef(ctx, m->full_name, m, exts[i], &m->nested_exts[i],
- /* is_extension= */ true);
- ((upb_FieldDef*)&m->nested_exts[i])->index_ = i;
- }
-
- const google_protobuf_DescriptorProto* const* msgs =
- google_protobuf_DescriptorProto_nested_type(msg_proto, &n);
- m->nested_msg_count = n;
- m->nested_msgs = symtab_alloc(ctx, sizeof(*m->nested_msgs) * n);
- for (size_t i = 0; i < n; i++) {
- create_msgdef(ctx, m->full_name, msgs[i], m, &m->nested_msgs[i]);
- }
-}
-
-static void resolve_subdef(symtab_addctx* ctx, const char* prefix,
- upb_FieldDef* f) {
- const google_protobuf_FieldDescriptorProto* field_proto = f->sub.unresolved;
- upb_StringView name =
- google_protobuf_FieldDescriptorProto_type_name(field_proto);
- bool has_name =
- google_protobuf_FieldDescriptorProto_has_type_name(field_proto);
- switch ((int)f->type_) {
- case FIELD_TYPE_UNSPECIFIED: {
- // Type was not specified and must be inferred.
- UPB_ASSERT(has_name);
- upb_deftype_t type;
- const void* def =
- symtab_resolveany(ctx, f->full_name, prefix, name, &type);
- switch (type) {
- case UPB_DEFTYPE_ENUM:
- f->sub.enumdef = def;
- f->type_ = kUpb_FieldType_Enum;
- break;
- case UPB_DEFTYPE_MSG:
- f->sub.msgdef = def;
- f->type_ = kUpb_FieldType_Message; // It appears there is no way of
- // this being a group.
- break;
- default:
- symtab_errf(ctx, "Couldn't resolve type name for field %s",
- f->full_name);
- }
- }
- case kUpb_FieldType_Message:
- case kUpb_FieldType_Group:
- UPB_ASSERT(has_name);
- f->sub.msgdef =
- symtab_resolve(ctx, f->full_name, prefix, name, UPB_DEFTYPE_MSG);
- break;
- case kUpb_FieldType_Enum:
- UPB_ASSERT(has_name);
- f->sub.enumdef =
- symtab_resolve(ctx, f->full_name, prefix, name, UPB_DEFTYPE_ENUM);
- break;
- default:
- // No resolution necessary.
- break;
- }
-}
-
-static void resolve_extension(
- symtab_addctx* ctx, const char* prefix, upb_FieldDef* f,
- const google_protobuf_FieldDescriptorProto* field_proto) {
- if (!google_protobuf_FieldDescriptorProto_has_extendee(field_proto)) {
- symtab_errf(ctx, "extension for field '%s' had no extendee", f->full_name);
- }
-
- upb_StringView name =
- google_protobuf_FieldDescriptorProto_extendee(field_proto);
- const upb_MessageDef* m =
- symtab_resolve(ctx, f->full_name, prefix, name, UPB_DEFTYPE_MSG);
- f->msgdef = m;
-
- bool found = false;
-
- for (int i = 0, n = m->ext_range_count; i < n; i++) {
- const upb_ExtensionRange* r = &m->ext_ranges[i];
- if (r->start <= f->number_ && f->number_ < r->end) {
- found = true;
- break;
- }
- }
-
- if (!found) {
- symtab_errf(ctx,
- "field number %u in extension %s has no extension range in "
- "message %s",
- (unsigned)f->number_, f->full_name, f->msgdef->full_name);
- }
-
- const upb_MiniTable_Extension* ext = ctx->file->ext_layouts[f->layout_index];
- if (ctx->layout) {
- UPB_ASSERT(upb_FieldDef_Number(f) == ext->field.number);
- } else {
- upb_MiniTable_Extension* mut_ext = (upb_MiniTable_Extension*)ext;
- fill_fieldlayout(&mut_ext->field, f);
- mut_ext->field.presence = 0;
- mut_ext->field.offset = 0;
- mut_ext->field.submsg_index = 0;
- mut_ext->extendee = f->msgdef->layout;
- mut_ext->sub.submsg = f->sub.msgdef->layout;
- }
-
- CHK_OOM(upb_inttable_insert(&ctx->symtab->exts, (uintptr_t)ext,
- upb_value_constptr(f), ctx->arena));
-}
-
-static void resolve_default(
- symtab_addctx* ctx, upb_FieldDef* f,
- const google_protobuf_FieldDescriptorProto* field_proto) {
- // Have to delay resolving of the default value until now because of the enum
- // case, since enum defaults are specified with a label.
- if (google_protobuf_FieldDescriptorProto_has_default_value(field_proto)) {
- upb_StringView defaultval =
- google_protobuf_FieldDescriptorProto_default_value(field_proto);
-
- if (f->file->syntax == kUpb_Syntax_Proto3) {
- symtab_errf(ctx, "proto3 fields cannot have explicit defaults (%s)",
- f->full_name);
- }
-
- if (upb_FieldDef_IsSubMessage(f)) {
- symtab_errf(ctx, "message fields cannot have explicit defaults (%s)",
- f->full_name);
- }
-
- parse_default(ctx, defaultval.data, defaultval.size, f);
- f->has_default = true;
- } else {
- set_default_default(ctx, f);
- f->has_default = false;
- }
-}
-
-static void resolve_fielddef(symtab_addctx* ctx, const char* prefix,
- upb_FieldDef* f) {
- // We have to stash this away since resolve_subdef() may overwrite it.
- const google_protobuf_FieldDescriptorProto* field_proto = f->sub.unresolved;
-
- resolve_subdef(ctx, prefix, f);
- resolve_default(ctx, f, field_proto);
-
- if (f->is_extension_) {
- resolve_extension(ctx, prefix, f, field_proto);
- }
-}
-
-static void resolve_msgdef(symtab_addctx* ctx, upb_MessageDef* m) {
- for (int i = 0; i < m->field_count; i++) {
- resolve_fielddef(ctx, m->full_name, (upb_FieldDef*)&m->fields[i]);
- }
-
- m->in_message_set = false;
- for (int i = 0; i < m->nested_ext_count; i++) {
- upb_FieldDef* ext = (upb_FieldDef*)&m->nested_exts[i];
- resolve_fielddef(ctx, m->full_name, ext);
- if (ext->type_ == kUpb_FieldType_Message &&
- ext->label_ == kUpb_Label_Optional && ext->sub.msgdef == m &&
- google_protobuf_MessageOptions_message_set_wire_format(
- ext->msgdef->opts)) {
- m->in_message_set = true;
- }
- }
-
- if (!ctx->layout) make_layout(ctx, m);
-
- for (int i = 0; i < m->nested_msg_count; i++) {
- resolve_msgdef(ctx, (upb_MessageDef*)&m->nested_msgs[i]);
- }
-}
-
-static int count_exts_in_msg(const google_protobuf_DescriptorProto* msg_proto) {
- size_t n;
- google_protobuf_DescriptorProto_extension(msg_proto, &n);
- int ext_count = n;
-
- const google_protobuf_DescriptorProto* const* nested_msgs =
- google_protobuf_DescriptorProto_nested_type(msg_proto, &n);
- for (size_t i = 0; i < n; i++) {
- ext_count += count_exts_in_msg(nested_msgs[i]);
- }
-
- return ext_count;
-}
-
-static void build_filedef(
- symtab_addctx* ctx, upb_FileDef* file,
- const google_protobuf_FileDescriptorProto* file_proto) {
- const google_protobuf_DescriptorProto* const* msgs;
- const google_protobuf_EnumDescriptorProto* const* enums;
- const google_protobuf_FieldDescriptorProto* const* exts;
- const google_protobuf_ServiceDescriptorProto* const* services;
- const upb_StringView* strs;
- const int32_t* public_deps;
- const int32_t* weak_deps;
- size_t i, n;
-
- file->symtab = ctx->symtab;
-
- /* Count all extensions in the file, to build a flat array of layouts. */
- google_protobuf_FileDescriptorProto_extension(file_proto, &n);
- int ext_count = n;
- msgs = google_protobuf_FileDescriptorProto_message_type(file_proto, &n);
- for (int i = 0; i < n; i++) {
- ext_count += count_exts_in_msg(msgs[i]);
- }
- file->ext_count = ext_count;
-
- if (ctx->layout) {
- /* We are using the ext layouts that were passed in. */
- file->ext_layouts = ctx->layout->exts;
- if (ctx->layout->ext_count != file->ext_count) {
- symtab_errf(ctx, "Extension count did not match layout (%d vs %d)",
- ctx->layout->ext_count, file->ext_count);
- }
- } else {
- /* We are building ext layouts from scratch. */
- file->ext_layouts =
- symtab_alloc(ctx, sizeof(*file->ext_layouts) * file->ext_count);
- upb_MiniTable_Extension* ext =
- symtab_alloc(ctx, sizeof(*ext) * file->ext_count);
- for (int i = 0; i < file->ext_count; i++) {
- file->ext_layouts[i] = &ext[i];
- }
- }
-
- if (!google_protobuf_FileDescriptorProto_has_name(file_proto)) {
- symtab_errf(ctx, "File has no name");
- }
-
- file->name =
- strviewdup(ctx, google_protobuf_FileDescriptorProto_name(file_proto));
-
- if (google_protobuf_FileDescriptorProto_has_package(file_proto)) {
- upb_StringView package =
- google_protobuf_FileDescriptorProto_package(file_proto);
- check_ident(ctx, package, true);
- file->package = strviewdup(ctx, package);
- } else {
- file->package = NULL;
- }
-
- if (google_protobuf_FileDescriptorProto_has_syntax(file_proto)) {
- upb_StringView syntax =
- google_protobuf_FileDescriptorProto_syntax(file_proto);
-
- if (streql_view(syntax, "proto2")) {
- file->syntax = kUpb_Syntax_Proto2;
- } else if (streql_view(syntax, "proto3")) {
- file->syntax = kUpb_Syntax_Proto3;
- } else {
- symtab_errf(ctx, "Invalid syntax '" UPB_STRINGVIEW_FORMAT "'",
- UPB_STRINGVIEW_ARGS(syntax));
- }
- } else {
- file->syntax = kUpb_Syntax_Proto2;
- }
-
- /* Read options. */
- SET_OPTIONS(file->opts, FileDescriptorProto, FileOptions, file_proto);
-
- /* Verify dependencies. */
- strs = google_protobuf_FileDescriptorProto_dependency(file_proto, &n);
- file->dep_count = n;
- file->deps = symtab_alloc(ctx, sizeof(*file->deps) * n);
-
- for (i = 0; i < n; i++) {
- upb_StringView str = strs[i];
- file->deps[i] =
- upb_DefPool_FindFileByNameWithSize(ctx->symtab, str.data, str.size);
- if (!file->deps[i]) {
- symtab_errf(ctx,
- "Depends on file '" UPB_STRINGVIEW_FORMAT
- "', but it has not been loaded",
- UPB_STRINGVIEW_ARGS(str));
- }
- }
-
- public_deps =
- google_protobuf_FileDescriptorProto_public_dependency(file_proto, &n);
- file->public_dep_count = n;
- file->public_deps = symtab_alloc(ctx, sizeof(*file->public_deps) * n);
- int32_t* mutable_public_deps = (int32_t*)file->public_deps;
- for (i = 0; i < n; i++) {
- if (public_deps[i] >= file->dep_count) {
- symtab_errf(ctx, "public_dep %d is out of range", (int)public_deps[i]);
- }
- mutable_public_deps[i] = public_deps[i];
- }
-
- weak_deps =
- google_protobuf_FileDescriptorProto_weak_dependency(file_proto, &n);
- file->weak_dep_count = n;
- file->weak_deps = symtab_alloc(ctx, sizeof(*file->weak_deps) * n);
- int32_t* mutable_weak_deps = (int32_t*)file->weak_deps;
- for (i = 0; i < n; i++) {
- if (weak_deps[i] >= file->dep_count) {
- symtab_errf(ctx, "weak_dep %d is out of range", (int)weak_deps[i]);
- }
- mutable_weak_deps[i] = weak_deps[i];
- }
-
- /* Create enums. */
- enums = google_protobuf_FileDescriptorProto_enum_type(file_proto, &n);
- file->top_lvl_enum_count = n;
- file->top_lvl_enums = symtab_alloc(ctx, sizeof(*file->top_lvl_enums) * n);
- for (i = 0; i < n; i++) {
- create_enumdef(ctx, file->package, enums[i], NULL, &file->top_lvl_enums[i]);
- }
-
- /* Create extensions. */
- exts = google_protobuf_FileDescriptorProto_extension(file_proto, &n);
- file->top_lvl_ext_count = n;
- file->top_lvl_exts = symtab_alloc(ctx, sizeof(*file->top_lvl_exts) * n);
- for (i = 0; i < n; i++) {
- create_fielddef(ctx, file->package, NULL, exts[i], &file->top_lvl_exts[i],
- /* is_extension= */ true);
- ((upb_FieldDef*)&file->top_lvl_exts[i])->index_ = i;
- }
-
- /* Create messages. */
- msgs = google_protobuf_FileDescriptorProto_message_type(file_proto, &n);
- file->top_lvl_msg_count = n;
- file->top_lvl_msgs = symtab_alloc(ctx, sizeof(*file->top_lvl_msgs) * n);
- for (i = 0; i < n; i++) {
- create_msgdef(ctx, file->package, msgs[i], NULL, &file->top_lvl_msgs[i]);
- }
-
- /* Create services. */
- services = google_protobuf_FileDescriptorProto_service(file_proto, &n);
- file->service_count = n;
- file->services = symtab_alloc(ctx, sizeof(*file->services) * n);
- for (i = 0; i < n; i++) {
- create_service(ctx, services[i], &file->services[i]);
- ((upb_ServiceDef*)&file->services[i])->index = i;
- }
-
- /* Now that all names are in the table, build layouts and resolve refs. */
- for (i = 0; i < (size_t)file->top_lvl_ext_count; i++) {
- resolve_fielddef(ctx, file->package, (upb_FieldDef*)&file->top_lvl_exts[i]);
- }
-
- for (i = 0; i < (size_t)file->top_lvl_msg_count; i++) {
- resolve_msgdef(ctx, (upb_MessageDef*)&file->top_lvl_msgs[i]);
- }
-
- if (file->ext_count) {
- CHK_OOM(_upb_extreg_add(ctx->symtab->extreg, file->ext_layouts,
- file->ext_count));
- }
-}
-
-static void remove_filedef(upb_DefPool* s, upb_FileDef* file) {
- intptr_t iter = UPB_INTTABLE_BEGIN;
- upb_StringView key;
- upb_value val;
- while (upb_strtable_next2(&s->syms, &key, &val, &iter)) {
- const upb_FileDef* f;
- switch (deftype(val)) {
- case UPB_DEFTYPE_EXT:
- f = upb_FieldDef_File(unpack_def(val, UPB_DEFTYPE_EXT));
- break;
- case UPB_DEFTYPE_MSG:
- f = upb_MessageDef_File(unpack_def(val, UPB_DEFTYPE_MSG));
- break;
- case UPB_DEFTYPE_ENUM:
- f = upb_EnumDef_File(unpack_def(val, UPB_DEFTYPE_ENUM));
- break;
- case UPB_DEFTYPE_ENUMVAL:
- f = upb_EnumDef_File(
- upb_EnumValueDef_Enum(unpack_def(val, UPB_DEFTYPE_ENUMVAL)));
- break;
- case UPB_DEFTYPE_SERVICE:
- f = upb_ServiceDef_File(unpack_def(val, UPB_DEFTYPE_SERVICE));
- break;
- default:
- UPB_UNREACHABLE();
- }
-
- if (f == file) upb_strtable_removeiter(&s->syms, &iter);
- }
-}
-
-static const upb_FileDef* _upb_DefPool_AddFile(
- upb_DefPool* s, const google_protobuf_FileDescriptorProto* file_proto,
- const upb_MiniTable_File* layout, upb_Status* status) {
- symtab_addctx ctx;
- upb_StringView name = google_protobuf_FileDescriptorProto_name(file_proto);
- upb_value v;
-
- if (upb_strtable_lookup2(&s->files, name.data, name.size, &v)) {
- if (unpack_def(v, UPB_DEFTYPE_FILE)) {
- upb_Status_SetErrorFormat(status, "duplicate file name (%.*s)",
- UPB_STRINGVIEW_ARGS(name));
- return NULL;
- }
- const upb_MiniTable_File* registered = unpack_def(v, UPB_DEFTYPE_LAYOUT);
- UPB_ASSERT(registered);
- if (layout && layout != registered) {
- upb_Status_SetErrorFormat(
- status, "tried to build with a different layout (filename=%.*s)",
- UPB_STRINGVIEW_ARGS(name));
- return NULL;
- }
- layout = registered;
- }
-
- ctx.symtab = s;
- ctx.layout = layout;
- ctx.msg_count = 0;
- ctx.enum_count = 0;
- ctx.ext_count = 0;
- ctx.status = status;
- ctx.file = NULL;
- ctx.arena = upb_Arena_New();
- ctx.tmp_arena = upb_Arena_New();
-
- if (!ctx.arena || !ctx.tmp_arena) {
- if (ctx.arena) upb_Arena_Free(ctx.arena);
- if (ctx.tmp_arena) upb_Arena_Free(ctx.tmp_arena);
- upb_Status_setoom(status);
- return NULL;
- }
-
- if (UPB_UNLIKELY(UPB_SETJMP(ctx.err))) {
- UPB_ASSERT(!upb_Status_IsOk(status));
- if (ctx.file) {
- remove_filedef(s, ctx.file);
- ctx.file = NULL;
- }
- } else {
- ctx.file = symtab_alloc(&ctx, sizeof(*ctx.file));
- build_filedef(&ctx, ctx.file, file_proto);
- upb_strtable_insert(&s->files, name.data, name.size,
- pack_def(ctx.file, UPB_DEFTYPE_FILE), ctx.arena);
- UPB_ASSERT(upb_Status_IsOk(status));
- upb_Arena_Fuse(s->arena, ctx.arena);
- }
-
- upb_Arena_Free(ctx.arena);
- upb_Arena_Free(ctx.tmp_arena);
- return ctx.file;
-}
-
-const upb_FileDef* upb_DefPool_AddFile(
- upb_DefPool* s, const google_protobuf_FileDescriptorProto* file_proto,
- upb_Status* status) {
- return _upb_DefPool_AddFile(s, file_proto, NULL, status);
-}
-
-/* Include here since we want most of this file to be stdio-free. */
-#include <stdio.h>
-
-bool _upb_DefPool_LoadDefInitEx(upb_DefPool* s, const _upb_DefPool_Init* init,
- bool rebuild_minitable) {
- /* Since this function should never fail (it would indicate a bug in upb) we
- * print errors to stderr instead of returning error status to the user. */
- _upb_DefPool_Init** deps = init->deps;
- google_protobuf_FileDescriptorProto* file;
- upb_Arena* arena;
- upb_Status status;
-
- upb_Status_Clear(&status);
-
- if (upb_DefPool_FindFileByName(s, init->filename)) {
- return true;
- }
-
- arena = upb_Arena_New();
-
- for (; *deps; deps++) {
- if (!_upb_DefPool_LoadDefInitEx(s, *deps, rebuild_minitable)) goto err;
- }
-
- file = google_protobuf_FileDescriptorProto_parse_ex(
- init->descriptor.data, init->descriptor.size, NULL,
- kUpb_DecodeOption_AliasString, arena);
- s->bytes_loaded += init->descriptor.size;
-
- if (!file) {
- upb_Status_SetErrorFormat(
- &status,
- "Failed to parse compiled-in descriptor for file '%s'. This should "
- "never happen.",
- init->filename);
- goto err;
- }
-
- const upb_MiniTable_File* mt = rebuild_minitable ? NULL : init->layout;
- if (!_upb_DefPool_AddFile(s, file, mt, &status)) {
- goto err;
- }
-
- upb_Arena_Free(arena);
- return true;
-
-err:
- fprintf(stderr,
- "Error loading compiled-in descriptor for file '%s' (this should "
- "never happen): %s\n",
- init->filename, upb_Status_ErrorMessage(&status));
- upb_Arena_Free(arena);
- return false;
-}
-
-size_t _upb_DefPool_BytesLoaded(const upb_DefPool* s) {
- return s->bytes_loaded;
-}
-
-upb_Arena* _upb_DefPool_Arena(const upb_DefPool* s) { return s->arena; }
-
-const upb_FieldDef* _upb_DefPool_FindExtensionByMiniTable(
- const upb_DefPool* s, const upb_MiniTable_Extension* ext) {
- upb_value v;
- bool ok = upb_inttable_lookup(&s->exts, (uintptr_t)ext, &v);
- UPB_ASSERT(ok);
- return upb_value_getconstptr(v);
-}
-
-const upb_FieldDef* upb_DefPool_FindExtensionByNumber(const upb_DefPool* s,
- const upb_MessageDef* m,
- int32_t fieldnum) {
- const upb_MiniTable* l = upb_MessageDef_MiniTable(m);
- const upb_MiniTable_Extension* ext = _upb_extreg_get(s->extreg, l, fieldnum);
- return ext ? _upb_DefPool_FindExtensionByMiniTable(s, ext) : NULL;
-}
-
-bool _upb_DefPool_registerlayout(upb_DefPool* s, const char* filename,
- const upb_MiniTable_File* file) {
- if (upb_DefPool_FindFileByName(s, filename)) return false;
- upb_value v = pack_def(file, UPB_DEFTYPE_LAYOUT);
- return upb_strtable_insert(&s->files, filename, strlen(filename), v,
- s->arena);
-}
-
-const upb_ExtensionRegistry* upb_DefPool_ExtensionRegistry(
- const upb_DefPool* s) {
- return s->extreg;
-}
-
-const upb_FieldDef** upb_DefPool_GetAllExtensions(const upb_DefPool* s,
- const upb_MessageDef* m,
- size_t* count) {
- size_t n = 0;
- intptr_t iter = UPB_INTTABLE_BEGIN;
- uintptr_t key;
- upb_value val;
- // This is O(all exts) instead of O(exts for m). If we need this to be
- // efficient we may need to make extreg into a two-level table, or have a
- // second per-message index.
- while (upb_inttable_next2(&s->exts, &key, &val, &iter)) {
- const upb_FieldDef* f = upb_value_getconstptr(val);
- if (upb_FieldDef_ContainingType(f) == m) n++;
- }
- const upb_FieldDef** exts = malloc(n * sizeof(*exts));
- iter = UPB_INTTABLE_BEGIN;
- size_t i = 0;
- while (upb_inttable_next2(&s->exts, &key, &val, &iter)) {
- const upb_FieldDef* f = upb_value_getconstptr(val);
- if (upb_FieldDef_ContainingType(f) == m) exts[i++] = f;
- }
- *count = n;
- return exts;
-}
-
-#undef CHK_OOM
-
-/** upb/reflection.c ************************************************************/
-
-#include <string.h>
-
-
-static size_t get_field_size(const upb_MiniTable_Field* f) {
- static unsigned char sizes[] = {
- 0, /* 0 */
- 8, /* kUpb_FieldType_Double */
- 4, /* kUpb_FieldType_Float */
- 8, /* kUpb_FieldType_Int64 */
- 8, /* kUpb_FieldType_UInt64 */
- 4, /* kUpb_FieldType_Int32 */
- 8, /* kUpb_FieldType_Fixed64 */
- 4, /* kUpb_FieldType_Fixed32 */
- 1, /* kUpb_FieldType_Bool */
- sizeof(upb_StringView), /* kUpb_FieldType_String */
- sizeof(void*), /* kUpb_FieldType_Group */
- sizeof(void*), /* kUpb_FieldType_Message */
- sizeof(upb_StringView), /* kUpb_FieldType_Bytes */
- 4, /* kUpb_FieldType_UInt32 */
- 4, /* kUpb_FieldType_Enum */
- 4, /* kUpb_FieldType_SFixed32 */
- 8, /* kUpb_FieldType_SFixed64 */
- 4, /* kUpb_FieldType_SInt32 */
- 8, /* kUpb_FieldType_SInt64 */
- };
- return upb_IsRepeatedOrMap(f) ? sizeof(void*) : sizes[f->descriptortype];
-}
-
-/* Strings/bytes are special-cased in maps. */
-static char _upb_CTypeo_mapsize[12] = {
- 0,
- 1, /* kUpb_CType_Bool */
- 4, /* kUpb_CType_Float */
- 4, /* kUpb_CType_Int32 */
- 4, /* kUpb_CType_UInt32 */
- 4, /* kUpb_CType_Enum */
- sizeof(void*), /* kUpb_CType_Message */
- 8, /* kUpb_CType_Double */
- 8, /* kUpb_CType_Int64 */
- 8, /* kUpb_CType_UInt64 */
- 0, /* kUpb_CType_String */
- 0, /* kUpb_CType_Bytes */
-};
-
-static const char _upb_CTypeo_sizelg2[12] = {
- 0,
- 0, /* kUpb_CType_Bool */
- 2, /* kUpb_CType_Float */
- 2, /* kUpb_CType_Int32 */
- 2, /* kUpb_CType_UInt32 */
- 2, /* kUpb_CType_Enum */
- UPB_SIZE(2, 3), /* kUpb_CType_Message */
- 3, /* kUpb_CType_Double */
- 3, /* kUpb_CType_Int64 */
- 3, /* kUpb_CType_UInt64 */
- UPB_SIZE(3, 4), /* kUpb_CType_String */
- UPB_SIZE(3, 4), /* kUpb_CType_Bytes */
-};
-
-/** upb_Message
- * *******************************************************************/
-
-upb_Message* upb_Message_New(const upb_MessageDef* m, upb_Arena* a) {
- return _upb_Message_New(upb_MessageDef_MiniTable(m), a);
-}
-
-static bool in_oneof(const upb_MiniTable_Field* field) {
- return field->presence < 0;
-}
-
-static upb_MessageValue _upb_Message_Getraw(const upb_Message* msg,
- const upb_FieldDef* f) {
- const upb_MiniTable_Field* field = upb_FieldDef_MiniTable(f);
- const char* mem = UPB_PTR_AT(msg, field->offset, char);
- upb_MessageValue val = {0};
- memcpy(&val, mem, get_field_size(field));
- return val;
-}
-
-bool upb_Message_Has(const upb_Message* msg, const upb_FieldDef* f) {
- assert(upb_FieldDef_HasPresence(f));
- if (upb_FieldDef_IsExtension(f)) {
- const upb_MiniTable_Extension* ext = _upb_FieldDef_ExtensionMiniTable(f);
- return _upb_Message_Getext(msg, ext) != NULL;
- } else {
- const upb_MiniTable_Field* field = upb_FieldDef_MiniTable(f);
- if (in_oneof(field)) {
- return _upb_getoneofcase_field(msg, field) == field->number;
- } else if (field->presence > 0) {
- return _upb_hasbit_field(msg, field);
- } else {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
- field->descriptortype == kUpb_FieldType_Group);
- return _upb_Message_Getraw(msg, f).msg_val != NULL;
- }
- }
-}
-
-const upb_FieldDef* upb_Message_WhichOneof(const upb_Message* msg,
- const upb_OneofDef* o) {
- const upb_FieldDef* f = upb_OneofDef_Field(o, 0);
- if (upb_OneofDef_IsSynthetic(o)) {
- UPB_ASSERT(upb_OneofDef_FieldCount(o) == 1);
- return upb_Message_Has(msg, f) ? f : NULL;
- } else {
- const upb_MiniTable_Field* field = upb_FieldDef_MiniTable(f);
- uint32_t oneof_case = _upb_getoneofcase_field(msg, field);
- f = oneof_case ? upb_OneofDef_LookupNumber(o, oneof_case) : NULL;
- UPB_ASSERT((f != NULL) == (oneof_case != 0));
- return f;
- }
-}
-
-upb_MessageValue upb_Message_Get(const upb_Message* msg,
- const upb_FieldDef* f) {
- if (upb_FieldDef_IsExtension(f)) {
- const upb_Message_Extension* ext =
- _upb_Message_Getext(msg, _upb_FieldDef_ExtensionMiniTable(f));
- if (ext) {
- upb_MessageValue val;
- memcpy(&val, &ext->data, sizeof(val));
- return val;
- } else if (upb_FieldDef_IsRepeated(f)) {
- return (upb_MessageValue){.array_val = NULL};
- }
- } else if (!upb_FieldDef_HasPresence(f) || upb_Message_Has(msg, f)) {
- return _upb_Message_Getraw(msg, f);
- }
- return upb_FieldDef_Default(f);
-}
-
-upb_MutableMessageValue upb_Message_Mutable(upb_Message* msg,
- const upb_FieldDef* f,
- upb_Arena* a) {
- UPB_ASSERT(upb_FieldDef_IsSubMessage(f) || upb_FieldDef_IsRepeated(f));
- if (upb_FieldDef_HasPresence(f) && !upb_Message_Has(msg, f)) {
- // We need to skip the upb_Message_Get() call in this case.
- goto make;
- }
-
- upb_MessageValue val = upb_Message_Get(msg, f);
- if (val.array_val) {
- return (upb_MutableMessageValue){.array = (upb_Array*)val.array_val};
- }
-
- upb_MutableMessageValue ret;
-make:
- if (!a) return (upb_MutableMessageValue){.array = NULL};
- if (upb_FieldDef_IsMap(f)) {
- const upb_MessageDef* entry = upb_FieldDef_MessageSubDef(f);
- const upb_FieldDef* key =
- upb_MessageDef_FindFieldByNumber(entry, kUpb_MapEntry_KeyFieldNumber);
- const upb_FieldDef* value =
- upb_MessageDef_FindFieldByNumber(entry, kUpb_MapEntry_ValueFieldNumber);
- ret.map =
- upb_Map_New(a, upb_FieldDef_CType(key), upb_FieldDef_CType(value));
- } else if (upb_FieldDef_IsRepeated(f)) {
- ret.array = upb_Array_New(a, upb_FieldDef_CType(f));
- } else {
- UPB_ASSERT(upb_FieldDef_IsSubMessage(f));
- ret.msg = upb_Message_New(upb_FieldDef_MessageSubDef(f), a);
- }
-
- val.array_val = ret.array;
- upb_Message_Set(msg, f, val, a);
-
- return ret;
-}
-
-bool upb_Message_Set(upb_Message* msg, const upb_FieldDef* f,
- upb_MessageValue val, upb_Arena* a) {
- if (upb_FieldDef_IsExtension(f)) {
- upb_Message_Extension* ext = _upb_Message_Getorcreateext(
- msg, _upb_FieldDef_ExtensionMiniTable(f), a);
- if (!ext) return false;
- memcpy(&ext->data, &val, sizeof(val));
- } else {
- const upb_MiniTable_Field* field = upb_FieldDef_MiniTable(f);
- char* mem = UPB_PTR_AT(msg, field->offset, char);
- memcpy(mem, &val, get_field_size(field));
- if (field->presence > 0) {
- _upb_sethas_field(msg, field);
- } else if (in_oneof(field)) {
- *_upb_oneofcase_field(msg, field) = field->number;
- }
- }
- return true;
-}
-
-void upb_Message_ClearField(upb_Message* msg, const upb_FieldDef* f) {
- if (upb_FieldDef_IsExtension(f)) {
- _upb_Message_Clearext(msg, _upb_FieldDef_ExtensionMiniTable(f));
- } else {
- const upb_MiniTable_Field* field = upb_FieldDef_MiniTable(f);
- char* mem = UPB_PTR_AT(msg, field->offset, char);
-
- if (field->presence > 0) {
- _upb_clearhas_field(msg, field);
- } else if (in_oneof(field)) {
- uint32_t* oneof_case = _upb_oneofcase_field(msg, field);
- if (*oneof_case != field->number) return;
- *oneof_case = 0;
- }
-
- memset(mem, 0, get_field_size(field));
- }
-}
-
-void upb_Message_Clear(upb_Message* msg, const upb_MessageDef* m) {
- _upb_Message_Clear(msg, upb_MessageDef_MiniTable(m));
-}
-
-bool upb_Message_Next(const upb_Message* msg, const upb_MessageDef* m,
- const upb_DefPool* ext_pool, const upb_FieldDef** out_f,
- upb_MessageValue* out_val, size_t* iter) {
- size_t i = *iter;
- size_t n = upb_MessageDef_FieldCount(m);
- const upb_MessageValue zero = {0};
- UPB_UNUSED(ext_pool);
-
- /* Iterate over normal fields, returning the first one that is set. */
- while (++i < n) {
- const upb_FieldDef* f = upb_MessageDef_Field(m, i);
- upb_MessageValue val = _upb_Message_Getraw(msg, f);
-
- /* Skip field if unset or empty. */
- if (upb_FieldDef_HasPresence(f)) {
- if (!upb_Message_Has(msg, f)) continue;
- } else {
- upb_MessageValue test = val;
- if (upb_FieldDef_IsString(f) && !upb_FieldDef_IsRepeated(f)) {
- /* Clear string pointer, only size matters (ptr could be non-NULL). */
- test.str_val.data = NULL;
- }
- /* Continue if NULL or 0. */
- if (memcmp(&test, &zero, sizeof(test)) == 0) continue;
-
- /* Continue on empty array or map. */
- if (upb_FieldDef_IsMap(f)) {
- if (upb_Map_Size(test.map_val) == 0) continue;
- } else if (upb_FieldDef_IsRepeated(f)) {
- if (upb_Array_Size(test.array_val) == 0) continue;
- }
- }
-
- *out_val = val;
- *out_f = f;
- *iter = i;
- return true;
- }
-
- if (ext_pool) {
- /* Return any extensions that are set. */
- size_t count;
- const upb_Message_Extension* ext = _upb_Message_Getexts(msg, &count);
- if (i - n < count) {
- ext += count - 1 - (i - n);
- memcpy(out_val, &ext->data, sizeof(*out_val));
- *out_f = _upb_DefPool_FindExtensionByMiniTable(ext_pool, ext->ext);
- *iter = i;
- return true;
- }
- }
-
- *iter = i;
- return false;
-}
-
-bool _upb_Message_DiscardUnknown(upb_Message* msg, const upb_MessageDef* m,
- int depth) {
- size_t iter = kUpb_Message_Begin;
- const upb_FieldDef* f;
- upb_MessageValue val;
- bool ret = true;
-
- if (--depth == 0) return false;
-
- _upb_Message_DiscardUnknown_shallow(msg);
-
- while (upb_Message_Next(msg, m, NULL /*ext_pool*/, &f, &val, &iter)) {
- const upb_MessageDef* subm = upb_FieldDef_MessageSubDef(f);
- if (!subm) continue;
- if (upb_FieldDef_IsMap(f)) {
- const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(subm, 2);
- const upb_MessageDef* val_m = upb_FieldDef_MessageSubDef(val_f);
- upb_Map* map = (upb_Map*)val.map_val;
- size_t iter = kUpb_Map_Begin;
-
- if (!val_m) continue;
-
- while (upb_MapIterator_Next(map, &iter)) {
- upb_MessageValue map_val = upb_MapIterator_Value(map, iter);
- if (!_upb_Message_DiscardUnknown((upb_Message*)map_val.msg_val, val_m,
- depth)) {
- ret = false;
- }
- }
- } else if (upb_FieldDef_IsRepeated(f)) {
- const upb_Array* arr = val.array_val;
- size_t i, n = upb_Array_Size(arr);
- for (i = 0; i < n; i++) {
- upb_MessageValue elem = upb_Array_Get(arr, i);
- if (!_upb_Message_DiscardUnknown((upb_Message*)elem.msg_val, subm,
- depth)) {
- ret = false;
- }
- }
- } else {
- if (!_upb_Message_DiscardUnknown((upb_Message*)val.msg_val, subm,
- depth)) {
- ret = false;
- }
- }
- }
-
- return ret;
-}
-
-bool upb_Message_DiscardUnknown(upb_Message* msg, const upb_MessageDef* m,
- int maxdepth) {
- return _upb_Message_DiscardUnknown(msg, m, maxdepth);
-}
-
-/** upb_Array *****************************************************************/
-
-upb_Array* upb_Array_New(upb_Arena* a, upb_CType type) {
- return _upb_Array_New(a, 4, _upb_CTypeo_sizelg2[type]);
-}
-
-size_t upb_Array_Size(const upb_Array* arr) { return arr->len; }
-
-upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i) {
- upb_MessageValue ret;
- const char* data = _upb_array_constptr(arr);
- int lg2 = arr->data & 7;
- UPB_ASSERT(i < arr->len);
- memcpy(&ret, data + (i << lg2), 1 << lg2);
- return ret;
-}
-
-void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val) {
- char* data = _upb_array_ptr(arr);
- int lg2 = arr->data & 7;
- UPB_ASSERT(i < arr->len);
- memcpy(data + (i << lg2), &val, 1 << lg2);
-}
-
-bool upb_Array_Append(upb_Array* arr, upb_MessageValue val, upb_Arena* arena) {
- if (!upb_Array_Resize(arr, arr->len + 1, arena)) {
- return false;
- }
- upb_Array_Set(arr, arr->len - 1, val);
- return true;
-}
-
-void upb_Array_Move(upb_Array* arr, size_t dst_idx, size_t src_idx,
- size_t count) {
- char* data = _upb_array_ptr(arr);
- int lg2 = arr->data & 7;
- memmove(&data[dst_idx << lg2], &data[src_idx << lg2], count << lg2);
-}
-
-bool upb_Array_Insert(upb_Array* arr, size_t i, size_t count,
- upb_Arena* arena) {
- UPB_ASSERT(i <= arr->len);
- UPB_ASSERT(count + arr->len >= count);
- size_t oldsize = arr->len;
- if (!upb_Array_Resize(arr, arr->len + count, arena)) {
- return false;
- }
- upb_Array_Move(arr, i + count, i, oldsize - i);
- return true;
-}
-
-/*
- * i end arr->len
- * |------------|XXXXXXXX|--------|
- */
-void upb_Array_Delete(upb_Array* arr, size_t i, size_t count) {
- size_t end = i + count;
- UPB_ASSERT(i <= end);
- UPB_ASSERT(end <= arr->len);
- upb_Array_Move(arr, i, end, arr->len - end);
- arr->len -= count;
-}
-
-bool upb_Array_Resize(upb_Array* arr, size_t size, upb_Arena* arena) {
- return _upb_Array_Resize(arr, size, arena);
-}
-
-/** upb_Map *******************************************************************/
-
-upb_Map* upb_Map_New(upb_Arena* a, upb_CType key_type, upb_CType value_type) {
- return _upb_Map_New(a, _upb_CTypeo_mapsize[key_type],
- _upb_CTypeo_mapsize[value_type]);
-}
-
-size_t upb_Map_Size(const upb_Map* map) { return _upb_Map_Size(map); }
-
-bool upb_Map_Get(const upb_Map* map, upb_MessageValue key,
- upb_MessageValue* val) {
- return _upb_Map_Get(map, &key, map->key_size, val, map->val_size);
-}
-
-void upb_Map_Clear(upb_Map* map) { _upb_Map_Clear(map); }
-
-bool upb_Map_Set(upb_Map* map, upb_MessageValue key, upb_MessageValue val,
- upb_Arena* arena) {
- return _upb_Map_Set(map, &key, map->key_size, &val, map->val_size, arena);
-}
-
-bool upb_Map_Delete(upb_Map* map, upb_MessageValue key) {
- return _upb_Map_Delete(map, &key, map->key_size);
-}
-
-bool upb_MapIterator_Next(const upb_Map* map, size_t* iter) {
- return _upb_map_next(map, iter);
-}
-
-bool upb_MapIterator_Done(const upb_Map* map, size_t iter) {
- upb_strtable_iter i;
- UPB_ASSERT(iter != kUpb_Map_Begin);
- i.t = &map->table;
- i.index = iter;
- return upb_strtable_done(&i);
-}
-
-/* Returns the key and value for this entry of the map. */
-upb_MessageValue upb_MapIterator_Key(const upb_Map* map, size_t iter) {
- upb_strtable_iter i;
- upb_MessageValue ret;
- i.t = &map->table;
- i.index = iter;
- _upb_map_fromkey(upb_strtable_iter_key(&i), &ret, map->key_size);
- return ret;
-}
-
-upb_MessageValue upb_MapIterator_Value(const upb_Map* map, size_t iter) {
- upb_strtable_iter i;
- upb_MessageValue ret;
- i.t = &map->table;
- i.index = iter;
- _upb_map_fromvalue(upb_strtable_iter_value(&i), &ret, map->val_size);
- return ret;
-}
-
-/* void upb_MapIterator_SetValue(upb_Map *map, size_t iter, upb_MessageValue
- * value); */
-
-/** upb/json_decode.c ************************************************************/
-
-#include <errno.h>
-#include <float.h>
-#include <inttypes.h>
-#include <limits.h>
-#include <math.h>
-#include <setjmp.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-/* Special header, must be included last. */
-
-typedef struct {
- const char *ptr, *end;
- upb_Arena* arena; /* TODO: should we have a tmp arena for tmp data? */
- const upb_DefPool* symtab;
- int depth;
- upb_Status* status;
- jmp_buf err;
- int line;
- const char* line_begin;
- bool is_first;
- int options;
- const upb_FieldDef* debug_field;
-} jsondec;
-
-enum { JD_OBJECT, JD_ARRAY, JD_STRING, JD_NUMBER, JD_TRUE, JD_FALSE, JD_NULL };
-
-/* Forward declarations of mutually-recursive functions. */
-static void jsondec_wellknown(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m);
-static upb_MessageValue jsondec_value(jsondec* d, const upb_FieldDef* f);
-static void jsondec_wellknownvalue(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m);
-static void jsondec_object(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m);
-
-static bool jsondec_streql(upb_StringView str, const char* lit) {
- return str.size == strlen(lit) && memcmp(str.data, lit, str.size) == 0;
-}
-
-static bool jsondec_isnullvalue(const upb_FieldDef* f) {
- return upb_FieldDef_CType(f) == kUpb_CType_Enum &&
- strcmp(upb_EnumDef_FullName(upb_FieldDef_EnumSubDef(f)),
- "google.protobuf.NullValue") == 0;
-}
-
-static bool jsondec_isvalue(const upb_FieldDef* f) {
- return (upb_FieldDef_CType(f) == kUpb_CType_Message &&
- upb_MessageDef_WellKnownType(upb_FieldDef_MessageSubDef(f)) ==
- kUpb_WellKnown_Value) ||
- jsondec_isnullvalue(f);
-}
-
-UPB_NORETURN static void jsondec_err(jsondec* d, const char* msg) {
- upb_Status_SetErrorFormat(d->status, "Error parsing JSON @%d:%d: %s", d->line,
- (int)(d->ptr - d->line_begin), msg);
- UPB_LONGJMP(d->err, 1);
-}
-
-UPB_PRINTF(2, 3)
-UPB_NORETURN static void jsondec_errf(jsondec* d, const char* fmt, ...) {
- va_list argp;
- upb_Status_SetErrorFormat(d->status, "Error parsing JSON @%d:%d: ", d->line,
- (int)(d->ptr - d->line_begin));
- va_start(argp, fmt);
- upb_Status_VAppendErrorFormat(d->status, fmt, argp);
- va_end(argp);
- UPB_LONGJMP(d->err, 1);
-}
-
-static void jsondec_skipws(jsondec* d) {
- while (d->ptr != d->end) {
- switch (*d->ptr) {
- case '\n':
- d->line++;
- d->line_begin = d->ptr;
- /* Fallthrough. */
- case '\r':
- case '\t':
- case ' ':
- d->ptr++;
- break;
- default:
- return;
- }
- }
- jsondec_err(d, "Unexpected EOF");
-}
-
-static bool jsondec_tryparsech(jsondec* d, char ch) {
- if (d->ptr == d->end || *d->ptr != ch) return false;
- d->ptr++;
- return true;
-}
-
-static void jsondec_parselit(jsondec* d, const char* lit) {
- size_t avail = d->end - d->ptr;
- size_t len = strlen(lit);
- if (avail < len || memcmp(d->ptr, lit, len) != 0) {
- jsondec_errf(d, "Expected: '%s'", lit);
- }
- d->ptr += len;
-}
-
-static void jsondec_wsch(jsondec* d, char ch) {
- jsondec_skipws(d);
- if (!jsondec_tryparsech(d, ch)) {
- jsondec_errf(d, "Expected: '%c'", ch);
- }
-}
-
-static void jsondec_true(jsondec* d) { jsondec_parselit(d, "true"); }
-static void jsondec_false(jsondec* d) { jsondec_parselit(d, "false"); }
-static void jsondec_null(jsondec* d) { jsondec_parselit(d, "null"); }
-
-static void jsondec_entrysep(jsondec* d) {
- jsondec_skipws(d);
- jsondec_parselit(d, ":");
-}
-
-static int jsondec_rawpeek(jsondec* d) {
- switch (*d->ptr) {
- case '{':
- return JD_OBJECT;
- case '[':
- return JD_ARRAY;
- case '"':
- return JD_STRING;
- case '-':
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- return JD_NUMBER;
- case 't':
- return JD_TRUE;
- case 'f':
- return JD_FALSE;
- case 'n':
- return JD_NULL;
- default:
- jsondec_errf(d, "Unexpected character: '%c'", *d->ptr);
- }
-}
-
-/* JSON object/array **********************************************************/
-
-/* These are used like so:
- *
- * jsondec_objstart(d);
- * while (jsondec_objnext(d)) {
- * ...
- * }
- * jsondec_objend(d) */
-
-static int jsondec_peek(jsondec* d) {
- jsondec_skipws(d);
- return jsondec_rawpeek(d);
-}
-
-static void jsondec_push(jsondec* d) {
- if (--d->depth < 0) {
- jsondec_err(d, "Recursion limit exceeded");
- }
- d->is_first = true;
-}
-
-static bool jsondec_seqnext(jsondec* d, char end_ch) {
- bool is_first = d->is_first;
- d->is_first = false;
- jsondec_skipws(d);
- if (*d->ptr == end_ch) return false;
- if (!is_first) jsondec_parselit(d, ",");
- return true;
-}
-
-static void jsondec_arrstart(jsondec* d) {
- jsondec_push(d);
- jsondec_wsch(d, '[');
-}
-
-static void jsondec_arrend(jsondec* d) {
- d->depth++;
- jsondec_wsch(d, ']');
-}
-
-static bool jsondec_arrnext(jsondec* d) { return jsondec_seqnext(d, ']'); }
-
-static void jsondec_objstart(jsondec* d) {
- jsondec_push(d);
- jsondec_wsch(d, '{');
-}
-
-static void jsondec_objend(jsondec* d) {
- d->depth++;
- jsondec_wsch(d, '}');
-}
-
-static bool jsondec_objnext(jsondec* d) {
- if (!jsondec_seqnext(d, '}')) return false;
- if (jsondec_peek(d) != JD_STRING) {
- jsondec_err(d, "Object must start with string");
- }
- return true;
-}
-
-/* JSON number ****************************************************************/
-
-static bool jsondec_tryskipdigits(jsondec* d) {
- const char* start = d->ptr;
-
- while (d->ptr < d->end) {
- if (*d->ptr < '0' || *d->ptr > '9') {
- break;
- }
- d->ptr++;
- }
-
- return d->ptr != start;
-}
-
-static void jsondec_skipdigits(jsondec* d) {
- if (!jsondec_tryskipdigits(d)) {
- jsondec_err(d, "Expected one or more digits");
- }
-}
-
-static double jsondec_number(jsondec* d) {
- const char* start = d->ptr;
-
- assert(jsondec_rawpeek(d) == JD_NUMBER);
-
- /* Skip over the syntax of a number, as specified by JSON. */
- if (*d->ptr == '-') d->ptr++;
-
- if (jsondec_tryparsech(d, '0')) {
- if (jsondec_tryskipdigits(d)) {
- jsondec_err(d, "number cannot have leading zero");
- }
- } else {
- jsondec_skipdigits(d);
- }
-
- if (d->ptr == d->end) goto parse;
- if (jsondec_tryparsech(d, '.')) {
- jsondec_skipdigits(d);
- }
- if (d->ptr == d->end) goto parse;
-
- if (*d->ptr == 'e' || *d->ptr == 'E') {
- d->ptr++;
- if (d->ptr == d->end) {
- jsondec_err(d, "Unexpected EOF in number");
- }
- if (*d->ptr == '+' || *d->ptr == '-') {
- d->ptr++;
- }
- jsondec_skipdigits(d);
- }
-
-parse:
- /* Having verified the syntax of a JSON number, use strtod() to parse
- * (strtod() accepts a superset of JSON syntax). */
- errno = 0;
- {
- char* end;
- double val = strtod(start, &end);
- assert(end == d->ptr);
-
- /* Currently the min/max-val conformance tests fail if we check this. Does
- * this mean the conformance tests are wrong or strtod() is wrong, or
- * something else? Investigate further. */
- /*
- if (errno == ERANGE) {
- jsondec_err(d, "Number out of range");
- }
- */
-
- if (val > DBL_MAX || val < -DBL_MAX) {
- jsondec_err(d, "Number out of range");
- }
-
- return val;
- }
-}
-
-/* JSON string ****************************************************************/
-
-static char jsondec_escape(jsondec* d) {
- switch (*d->ptr++) {
- case '"':
- return '\"';
- case '\\':
- return '\\';
- case '/':
- return '/';
- case 'b':
- return '\b';
- case 'f':
- return '\f';
- case 'n':
- return '\n';
- case 'r':
- return '\r';
- case 't':
- return '\t';
- default:
- jsondec_err(d, "Invalid escape char");
- }
-}
-
-static uint32_t jsondec_codepoint(jsondec* d) {
- uint32_t cp = 0;
- const char* end;
-
- if (d->end - d->ptr < 4) {
- jsondec_err(d, "EOF inside string");
- }
-
- end = d->ptr + 4;
- while (d->ptr < end) {
- char ch = *d->ptr++;
- if (ch >= '0' && ch <= '9') {
- ch -= '0';
- } else if (ch >= 'a' && ch <= 'f') {
- ch = ch - 'a' + 10;
- } else if (ch >= 'A' && ch <= 'F') {
- ch = ch - 'A' + 10;
- } else {
- jsondec_err(d, "Invalid hex digit");
- }
- cp = (cp << 4) | ch;
- }
-
- return cp;
-}
-
-/* Parses a \uXXXX unicode escape (possibly a surrogate pair). */
-static size_t jsondec_unicode(jsondec* d, char* out) {
- uint32_t cp = jsondec_codepoint(d);
- if (cp >= 0xd800 && cp <= 0xdbff) {
- /* Surrogate pair: two 16-bit codepoints become a 32-bit codepoint. */
- uint32_t high = cp;
- uint32_t low;
- jsondec_parselit(d, "\\u");
- low = jsondec_codepoint(d);
- if (low < 0xdc00 || low > 0xdfff) {
- jsondec_err(d, "Invalid low surrogate");
- }
- cp = (high & 0x3ff) << 10;
- cp |= (low & 0x3ff);
- cp += 0x10000;
- } else if (cp >= 0xdc00 && cp <= 0xdfff) {
- jsondec_err(d, "Unpaired low surrogate");
- }
-
- /* Write to UTF-8 */
+int upb_Unicode_ToUTF8(uint32_t cp, char* out) {
if (cp <= 0x7f) {
out[0] = cp;
return 1;
- } else if (cp <= 0x07FF) {
- out[0] = ((cp >> 6) & 0x1F) | 0xC0;
- out[1] = ((cp >> 0) & 0x3F) | 0x80;
+ }
+ if (cp <= 0x07ff) {
+ out[0] = (cp >> 6) | 0xc0;
+ out[1] = (cp & 0x3f) | 0x80;
return 2;
- } else if (cp <= 0xFFFF) {
- out[0] = ((cp >> 12) & 0x0F) | 0xE0;
- out[1] = ((cp >> 6) & 0x3F) | 0x80;
- out[2] = ((cp >> 0) & 0x3F) | 0x80;
+ }
+ if (cp <= 0xffff) {
+ out[0] = (cp >> 12) | 0xe0;
+ out[1] = ((cp >> 6) & 0x3f) | 0x80;
+ out[2] = (cp & 0x3f) | 0x80;
return 3;
- } else if (cp < 0x10FFFF) {
- out[0] = ((cp >> 18) & 0x07) | 0xF0;
+ }
+ if (cp <= 0x10ffff) {
+ out[0] = (cp >> 18) | 0xf0;
out[1] = ((cp >> 12) & 0x3f) | 0x80;
out[2] = ((cp >> 6) & 0x3f) | 0x80;
- out[3] = ((cp >> 0) & 0x3f) | 0x80;
+ out[3] = (cp & 0x3f) | 0x80;
return 4;
- } else {
- jsondec_err(d, "Invalid codepoint");
}
-}
-
-static void jsondec_resize(jsondec* d, char** buf, char** end, char** buf_end) {
- size_t oldsize = *buf_end - *buf;
- size_t len = *end - *buf;
- size_t size = UPB_MAX(8, 2 * oldsize);
-
- *buf = upb_Arena_Realloc(d->arena, *buf, len, size);
- if (!*buf) jsondec_err(d, "Out of memory");
-
- *end = *buf + len;
- *buf_end = *buf + size;
-}
-
-static upb_StringView jsondec_string(jsondec* d) {
- char* buf = NULL;
- char* end = NULL;
- char* buf_end = NULL;
-
- jsondec_skipws(d);
-
- if (*d->ptr++ != '"') {
- jsondec_err(d, "Expected string");
- }
-
- while (d->ptr < d->end) {
- char ch = *d->ptr++;
-
- if (end == buf_end) {
- jsondec_resize(d, &buf, &end, &buf_end);
- }
-
- switch (ch) {
- case '"': {
- upb_StringView ret;
- ret.data = buf;
- ret.size = end - buf;
- *end = '\0'; /* Needed for possible strtod(). */
- return ret;
- }
- case '\\':
- if (d->ptr == d->end) goto eof;
- if (*d->ptr == 'u') {
- d->ptr++;
- if (buf_end - end < 4) {
- /* Allow space for maximum-sized code point (4 bytes). */
- jsondec_resize(d, &buf, &end, &buf_end);
- }
- end += jsondec_unicode(d, end);
- } else {
- *end++ = jsondec_escape(d);
- }
- break;
- default:
- if ((unsigned char)*d->ptr < 0x20) {
- jsondec_err(d, "Invalid char in JSON string");
- }
- *end++ = ch;
- break;
- }
- }
-
-eof:
- jsondec_err(d, "EOF inside string");
-}
-
-static void jsondec_skipval(jsondec* d) {
- switch (jsondec_peek(d)) {
- case JD_OBJECT:
- jsondec_objstart(d);
- while (jsondec_objnext(d)) {
- jsondec_string(d);
- jsondec_entrysep(d);
- jsondec_skipval(d);
- }
- jsondec_objend(d);
- break;
- case JD_ARRAY:
- jsondec_arrstart(d);
- while (jsondec_arrnext(d)) {
- jsondec_skipval(d);
- }
- jsondec_arrend(d);
- break;
- case JD_TRUE:
- jsondec_true(d);
- break;
- case JD_FALSE:
- jsondec_false(d);
- break;
- case JD_NULL:
- jsondec_null(d);
- break;
- case JD_STRING:
- jsondec_string(d);
- break;
- case JD_NUMBER:
- jsondec_number(d);
- break;
- }
-}
-
-/* Base64 decoding for bytes fields. ******************************************/
-
-static unsigned int jsondec_base64_tablelookup(const char ch) {
- /* Table includes the normal base64 chars plus the URL-safe variant. */
- const signed char table[256] = {
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, 62 /*+*/, -1, 62 /*-*/, -1, 63 /*/ */, 52 /*0*/,
- 53 /*1*/, 54 /*2*/, 55 /*3*/, 56 /*4*/, 57 /*5*/, 58 /*6*/, 59 /*7*/,
- 60 /*8*/, 61 /*9*/, -1, -1, -1, -1, -1,
- -1, -1, 0 /*A*/, 1 /*B*/, 2 /*C*/, 3 /*D*/, 4 /*E*/,
- 5 /*F*/, 6 /*G*/, 07 /*H*/, 8 /*I*/, 9 /*J*/, 10 /*K*/, 11 /*L*/,
- 12 /*M*/, 13 /*N*/, 14 /*O*/, 15 /*P*/, 16 /*Q*/, 17 /*R*/, 18 /*S*/,
- 19 /*T*/, 20 /*U*/, 21 /*V*/, 22 /*W*/, 23 /*X*/, 24 /*Y*/, 25 /*Z*/,
- -1, -1, -1, -1, 63 /*_*/, -1, 26 /*a*/,
- 27 /*b*/, 28 /*c*/, 29 /*d*/, 30 /*e*/, 31 /*f*/, 32 /*g*/, 33 /*h*/,
- 34 /*i*/, 35 /*j*/, 36 /*k*/, 37 /*l*/, 38 /*m*/, 39 /*n*/, 40 /*o*/,
- 41 /*p*/, 42 /*q*/, 43 /*r*/, 44 /*s*/, 45 /*t*/, 46 /*u*/, 47 /*v*/,
- 48 /*w*/, 49 /*x*/, 50 /*y*/, 51 /*z*/, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1};
-
- /* Sign-extend return value so high bit will be set on any unexpected char. */
- return table[(unsigned)ch];
-}
-
-static char* jsondec_partialbase64(jsondec* d, const char* ptr, const char* end,
- char* out) {
- int32_t val = -1;
-
- switch (end - ptr) {
- case 2:
- val = jsondec_base64_tablelookup(ptr[0]) << 18 |
- jsondec_base64_tablelookup(ptr[1]) << 12;
- out[0] = val >> 16;
- out += 1;
- break;
- case 3:
- val = jsondec_base64_tablelookup(ptr[0]) << 18 |
- jsondec_base64_tablelookup(ptr[1]) << 12 |
- jsondec_base64_tablelookup(ptr[2]) << 6;
- out[0] = val >> 16;
- out[1] = (val >> 8) & 0xff;
- out += 2;
- break;
- }
-
- if (val < 0) {
- jsondec_err(d, "Corrupt base64");
- }
-
- return out;
-}
-
-static size_t jsondec_base64(jsondec* d, upb_StringView str) {
- /* We decode in place. This is safe because this is a new buffer (not
- * aliasing the input) and because base64 decoding shrinks 4 bytes into 3. */
- char* out = (char*)str.data;
- const char* ptr = str.data;
- const char* end = ptr + str.size;
- const char* end4 = ptr + (str.size & -4); /* Round down to multiple of 4. */
-
- for (; ptr < end4; ptr += 4, out += 3) {
- int val = jsondec_base64_tablelookup(ptr[0]) << 18 |
- jsondec_base64_tablelookup(ptr[1]) << 12 |
- jsondec_base64_tablelookup(ptr[2]) << 6 |
- jsondec_base64_tablelookup(ptr[3]) << 0;
-
- if (val < 0) {
- /* Junk chars or padding. Remove trailing padding, if any. */
- if (end - ptr == 4 && ptr[3] == '=') {
- if (ptr[2] == '=') {
- end -= 2;
- } else {
- end -= 1;
- }
- }
- break;
- }
-
- out[0] = val >> 16;
- out[1] = (val >> 8) & 0xff;
- out[2] = val & 0xff;
- }
-
- if (ptr < end) {
- /* Process remaining chars. We do not require padding. */
- out = jsondec_partialbase64(d, ptr, end, out);
- }
-
- return out - str.data;
-}
-
-/* Low-level integer parsing **************************************************/
-
-/* We use these hand-written routines instead of strto[u]l() because the "long
- * long" variants aren't in c89. Also our version allows setting a ptr limit. */
-
-static const char* jsondec_buftouint64(jsondec* d, const char* ptr,
- const char* end, uint64_t* val) {
- uint64_t u64 = 0;
- while (ptr < end) {
- unsigned ch = *ptr - '0';
- if (ch >= 10) break;
- if (u64 > UINT64_MAX / 10 || u64 * 10 > UINT64_MAX - ch) {
- jsondec_err(d, "Integer overflow");
- }
- u64 *= 10;
- u64 += ch;
- ptr++;
- }
-
- *val = u64;
- return ptr;
-}
-
-static const char* jsondec_buftoint64(jsondec* d, const char* ptr,
- const char* end, int64_t* val) {
- bool neg = false;
- uint64_t u64;
-
- if (ptr != end && *ptr == '-') {
- ptr++;
- neg = true;
- }
-
- ptr = jsondec_buftouint64(d, ptr, end, &u64);
- if (u64 > (uint64_t)INT64_MAX + neg) {
- jsondec_err(d, "Integer overflow");
- }
-
- *val = neg ? -u64 : u64;
- return ptr;
-}
-
-static uint64_t jsondec_strtouint64(jsondec* d, upb_StringView str) {
- const char* end = str.data + str.size;
- uint64_t ret;
- if (jsondec_buftouint64(d, str.data, end, &ret) != end) {
- jsondec_err(d, "Non-number characters in quoted integer");
- }
- return ret;
-}
-
-static int64_t jsondec_strtoint64(jsondec* d, upb_StringView str) {
- const char* end = str.data + str.size;
- int64_t ret;
- if (jsondec_buftoint64(d, str.data, end, &ret) != end) {
- jsondec_err(d, "Non-number characters in quoted integer");
- }
- return ret;
-}
-
-/* Primitive value types ******************************************************/
-
-/* Parse INT32 or INT64 value. */
-static upb_MessageValue jsondec_int(jsondec* d, const upb_FieldDef* f) {
- upb_MessageValue val;
-
- switch (jsondec_peek(d)) {
- case JD_NUMBER: {
- double dbl = jsondec_number(d);
- if (dbl > 9223372036854774784.0 || dbl < -9223372036854775808.0) {
- jsondec_err(d, "JSON number is out of range.");
- }
- val.int64_val = dbl; /* must be guarded, overflow here is UB */
- if (val.int64_val != dbl) {
- jsondec_errf(d, "JSON number was not integral (%f != %" PRId64 ")", dbl,
- val.int64_val);
- }
- break;
- }
- case JD_STRING: {
- upb_StringView str = jsondec_string(d);
- val.int64_val = jsondec_strtoint64(d, str);
- break;
- }
- default:
- jsondec_err(d, "Expected number or string");
- }
-
- if (upb_FieldDef_CType(f) == kUpb_CType_Int32 ||
- upb_FieldDef_CType(f) == kUpb_CType_Enum) {
- if (val.int64_val > INT32_MAX || val.int64_val < INT32_MIN) {
- jsondec_err(d, "Integer out of range.");
- }
- val.int32_val = (int32_t)val.int64_val;
- }
-
- return val;
-}
-
-/* Parse UINT32 or UINT64 value. */
-static upb_MessageValue jsondec_uint(jsondec* d, const upb_FieldDef* f) {
- upb_MessageValue val = {0};
-
- switch (jsondec_peek(d)) {
- case JD_NUMBER: {
- double dbl = jsondec_number(d);
- if (dbl > 18446744073709549568.0 || dbl < 0) {
- jsondec_err(d, "JSON number is out of range.");
- }
- val.uint64_val = dbl; /* must be guarded, overflow here is UB */
- if (val.uint64_val != dbl) {
- jsondec_errf(d, "JSON number was not integral (%f != %" PRIu64 ")", dbl,
- val.uint64_val);
- }
- break;
- }
- case JD_STRING: {
- upb_StringView str = jsondec_string(d);
- val.uint64_val = jsondec_strtouint64(d, str);
- break;
- }
- default:
- jsondec_err(d, "Expected number or string");
- }
-
- if (upb_FieldDef_CType(f) == kUpb_CType_UInt32) {
- if (val.uint64_val > UINT32_MAX) {
- jsondec_err(d, "Integer out of range.");
- }
- val.uint32_val = (uint32_t)val.uint64_val;
- }
-
- return val;
-}
-
-/* Parse DOUBLE or FLOAT value. */
-static upb_MessageValue jsondec_double(jsondec* d, const upb_FieldDef* f) {
- upb_StringView str;
- upb_MessageValue val = {0};
-
- switch (jsondec_peek(d)) {
- case JD_NUMBER:
- val.double_val = jsondec_number(d);
- break;
- case JD_STRING:
- str = jsondec_string(d);
- if (jsondec_streql(str, "NaN")) {
- val.double_val = NAN;
- } else if (jsondec_streql(str, "Infinity")) {
- val.double_val = INFINITY;
- } else if (jsondec_streql(str, "-Infinity")) {
- val.double_val = -INFINITY;
- } else {
- val.double_val = strtod(str.data, NULL);
- }
- break;
- default:
- jsondec_err(d, "Expected number or string");
- }
-
- if (upb_FieldDef_CType(f) == kUpb_CType_Float) {
- if (val.double_val != INFINITY && val.double_val != -INFINITY &&
- (val.double_val > FLT_MAX || val.double_val < -FLT_MAX)) {
- jsondec_err(d, "Float out of range");
- }
- val.float_val = val.double_val;
- }
-
- return val;
-}
-
-/* Parse STRING or BYTES value. */
-static upb_MessageValue jsondec_strfield(jsondec* d, const upb_FieldDef* f) {
- upb_MessageValue val;
- val.str_val = jsondec_string(d);
- if (upb_FieldDef_CType(f) == kUpb_CType_Bytes) {
- val.str_val.size = jsondec_base64(d, val.str_val);
- }
- return val;
-}
-
-static upb_MessageValue jsondec_enum(jsondec* d, const upb_FieldDef* f) {
- switch (jsondec_peek(d)) {
- case JD_STRING: {
- upb_StringView str = jsondec_string(d);
- const upb_EnumDef* e = upb_FieldDef_EnumSubDef(f);
- const upb_EnumValueDef* ev =
- upb_EnumDef_FindValueByNameWithSize(e, str.data, str.size);
- upb_MessageValue val;
- if (ev) {
- val.int32_val = upb_EnumValueDef_Number(ev);
- } else {
- if (d->options & upb_JsonDecode_IgnoreUnknown) {
- val.int32_val = 0;
- } else {
- jsondec_errf(d, "Unknown enumerator: '" UPB_STRINGVIEW_FORMAT "'",
- UPB_STRINGVIEW_ARGS(str));
- }
- }
- return val;
- }
- case JD_NULL: {
- if (jsondec_isnullvalue(f)) {
- upb_MessageValue val;
- jsondec_null(d);
- val.int32_val = 0;
- return val;
- }
- }
- /* Fallthrough. */
- default:
- return jsondec_int(d, f);
- }
-}
-
-static upb_MessageValue jsondec_bool(jsondec* d, const upb_FieldDef* f) {
- bool is_map_key = upb_FieldDef_Number(f) == 1 &&
- upb_MessageDef_IsMapEntry(upb_FieldDef_ContainingType(f));
- upb_MessageValue val;
-
- if (is_map_key) {
- upb_StringView str = jsondec_string(d);
- if (jsondec_streql(str, "true")) {
- val.bool_val = true;
- } else if (jsondec_streql(str, "false")) {
- val.bool_val = false;
- } else {
- jsondec_err(d, "Invalid boolean map key");
- }
- } else {
- switch (jsondec_peek(d)) {
- case JD_TRUE:
- val.bool_val = true;
- jsondec_true(d);
- break;
- case JD_FALSE:
- val.bool_val = false;
- jsondec_false(d);
- break;
- default:
- jsondec_err(d, "Expected true or false");
- }
- }
-
- return val;
-}
-
-/* Composite types (array/message/map) ****************************************/
-
-static void jsondec_array(jsondec* d, upb_Message* msg, const upb_FieldDef* f) {
- upb_Array* arr = upb_Message_Mutable(msg, f, d->arena).array;
-
- jsondec_arrstart(d);
- while (jsondec_arrnext(d)) {
- upb_MessageValue elem = jsondec_value(d, f);
- upb_Array_Append(arr, elem, d->arena);
- }
- jsondec_arrend(d);
-}
-
-static void jsondec_map(jsondec* d, upb_Message* msg, const upb_FieldDef* f) {
- upb_Map* map = upb_Message_Mutable(msg, f, d->arena).map;
- const upb_MessageDef* entry = upb_FieldDef_MessageSubDef(f);
- const upb_FieldDef* key_f = upb_MessageDef_FindFieldByNumber(entry, 1);
- const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(entry, 2);
-
- jsondec_objstart(d);
- while (jsondec_objnext(d)) {
- upb_MessageValue key, val;
- key = jsondec_value(d, key_f);
- jsondec_entrysep(d);
- val = jsondec_value(d, val_f);
- upb_Map_Set(map, key, val, d->arena);
- }
- jsondec_objend(d);
-}
-
-static void jsondec_tomsg(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- if (upb_MessageDef_WellKnownType(m) == kUpb_WellKnown_Unspecified) {
- jsondec_object(d, msg, m);
- } else {
- jsondec_wellknown(d, msg, m);
- }
-}
-
-static upb_MessageValue jsondec_msg(jsondec* d, const upb_FieldDef* f) {
- const upb_MessageDef* m = upb_FieldDef_MessageSubDef(f);
- upb_Message* msg = upb_Message_New(m, d->arena);
- upb_MessageValue val;
-
- jsondec_tomsg(d, msg, m);
- val.msg_val = msg;
- return val;
-}
-
-static void jsondec_field(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- upb_StringView name;
- const upb_FieldDef* f;
- const upb_FieldDef* preserved;
-
- name = jsondec_string(d);
- jsondec_entrysep(d);
-
- if (name.size >= 2 && name.data[0] == '[' &&
- name.data[name.size - 1] == ']') {
- f = upb_DefPool_FindExtensionByNameWithSize(d->symtab, name.data + 1,
- name.size - 2);
- if (f && upb_FieldDef_ContainingType(f) != m) {
- jsondec_errf(
- d, "Extension %s extends message %s, but was seen in message %s",
- upb_FieldDef_FullName(f),
- upb_MessageDef_FullName(upb_FieldDef_ContainingType(f)),
- upb_MessageDef_FullName(m));
- }
- } else {
- f = upb_MessageDef_FindByJsonNameWithSize(m, name.data, name.size);
- }
-
- if (!f) {
- if ((d->options & upb_JsonDecode_IgnoreUnknown) == 0) {
- jsondec_errf(d, "No such field: " UPB_STRINGVIEW_FORMAT,
- UPB_STRINGVIEW_ARGS(name));
- }
- jsondec_skipval(d);
- return;
- }
-
- if (jsondec_peek(d) == JD_NULL && !jsondec_isvalue(f)) {
- /* JSON "null" indicates a default value, so no need to set anything. */
- jsondec_null(d);
- return;
- }
-
- if (upb_FieldDef_RealContainingOneof(f) &&
- upb_Message_WhichOneof(msg, upb_FieldDef_ContainingOneof(f))) {
- jsondec_err(d, "More than one field for this oneof.");
- }
-
- preserved = d->debug_field;
- d->debug_field = f;
-
- if (upb_FieldDef_IsMap(f)) {
- jsondec_map(d, msg, f);
- } else if (upb_FieldDef_IsRepeated(f)) {
- jsondec_array(d, msg, f);
- } else if (upb_FieldDef_IsSubMessage(f)) {
- upb_Message* submsg = upb_Message_Mutable(msg, f, d->arena).msg;
- const upb_MessageDef* subm = upb_FieldDef_MessageSubDef(f);
- jsondec_tomsg(d, submsg, subm);
- } else {
- upb_MessageValue val = jsondec_value(d, f);
- upb_Message_Set(msg, f, val, d->arena);
- }
-
- d->debug_field = preserved;
-}
-
-static void jsondec_object(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- jsondec_objstart(d);
- while (jsondec_objnext(d)) {
- jsondec_field(d, msg, m);
- }
- jsondec_objend(d);
-}
-
-static upb_MessageValue jsondec_value(jsondec* d, const upb_FieldDef* f) {
- switch (upb_FieldDef_CType(f)) {
- case kUpb_CType_Bool:
- return jsondec_bool(d, f);
- case kUpb_CType_Float:
- case kUpb_CType_Double:
- return jsondec_double(d, f);
- case kUpb_CType_UInt32:
- case kUpb_CType_UInt64:
- return jsondec_uint(d, f);
- case kUpb_CType_Int32:
- case kUpb_CType_Int64:
- return jsondec_int(d, f);
- case kUpb_CType_String:
- case kUpb_CType_Bytes:
- return jsondec_strfield(d, f);
- case kUpb_CType_Enum:
- return jsondec_enum(d, f);
- case kUpb_CType_Message:
- return jsondec_msg(d, f);
- default:
- UPB_UNREACHABLE();
- }
-}
-
-/* Well-known types ***********************************************************/
-
-static int jsondec_tsdigits(jsondec* d, const char** ptr, size_t digits,
- const char* after) {
- uint64_t val;
- const char* p = *ptr;
- const char* end = p + digits;
- size_t after_len = after ? strlen(after) : 0;
-
- UPB_ASSERT(digits <= 9); /* int can't overflow. */
-
- if (jsondec_buftouint64(d, p, end, &val) != end ||
- (after_len && memcmp(end, after, after_len) != 0)) {
- jsondec_err(d, "Malformed timestamp");
- }
-
- UPB_ASSERT(val < INT_MAX);
-
- *ptr = end + after_len;
- return (int)val;
-}
-
-static int jsondec_nanos(jsondec* d, const char** ptr, const char* end) {
- uint64_t nanos = 0;
- const char* p = *ptr;
-
- if (p != end && *p == '.') {
- const char* nano_end = jsondec_buftouint64(d, p + 1, end, &nanos);
- int digits = (int)(nano_end - p - 1);
- int exp_lg10 = 9 - digits;
- if (digits > 9) {
- jsondec_err(d, "Too many digits for partial seconds");
- }
- while (exp_lg10--) nanos *= 10;
- *ptr = nano_end;
- }
-
- UPB_ASSERT(nanos < INT_MAX);
-
- return (int)nanos;
-}
-
-/* jsondec_epochdays(1970, 1, 1) == 1970-01-01 == 0. */
-int jsondec_epochdays(int y, int m, int d) {
- const uint32_t year_base = 4800; /* Before min year, multiple of 400. */
- const uint32_t m_adj = m - 3; /* March-based month. */
- const uint32_t carry = m_adj > (uint32_t)m ? 1 : 0;
- const uint32_t adjust = carry ? 12 : 0;
- const uint32_t y_adj = y + year_base - carry;
- const uint32_t month_days = ((m_adj + adjust) * 62719 + 769) / 2048;
- const uint32_t leap_days = y_adj / 4 - y_adj / 100 + y_adj / 400;
- return y_adj * 365 + leap_days + month_days + (d - 1) - 2472632;
-}
-
-static int64_t jsondec_unixtime(int y, int m, int d, int h, int min, int s) {
- return (int64_t)jsondec_epochdays(y, m, d) * 86400 + h * 3600 + min * 60 + s;
-}
-
-static void jsondec_timestamp(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- upb_MessageValue seconds;
- upb_MessageValue nanos;
- upb_StringView str = jsondec_string(d);
- const char* ptr = str.data;
- const char* end = ptr + str.size;
-
- if (str.size < 20) goto malformed;
-
- {
- /* 1972-01-01T01:00:00 */
- int year = jsondec_tsdigits(d, &ptr, 4, "-");
- int mon = jsondec_tsdigits(d, &ptr, 2, "-");
- int day = jsondec_tsdigits(d, &ptr, 2, "T");
- int hour = jsondec_tsdigits(d, &ptr, 2, ":");
- int min = jsondec_tsdigits(d, &ptr, 2, ":");
- int sec = jsondec_tsdigits(d, &ptr, 2, NULL);
-
- seconds.int64_val = jsondec_unixtime(year, mon, day, hour, min, sec);
- }
-
- nanos.int32_val = jsondec_nanos(d, &ptr, end);
-
- {
- /* [+-]08:00 or Z */
- int ofs_hour = 0;
- int ofs_min = 0;
- bool neg = false;
-
- if (ptr == end) goto malformed;
-
- switch (*ptr++) {
- case '-':
- neg = true;
- /* fallthrough */
- case '+':
- if ((end - ptr) != 5) goto malformed;
- ofs_hour = jsondec_tsdigits(d, &ptr, 2, ":");
- ofs_min = jsondec_tsdigits(d, &ptr, 2, NULL);
- ofs_min = ((ofs_hour * 60) + ofs_min) * 60;
- seconds.int64_val += (neg ? ofs_min : -ofs_min);
- break;
- case 'Z':
- if (ptr != end) goto malformed;
- break;
- default:
- goto malformed;
- }
- }
-
- if (seconds.int64_val < -62135596800) {
- jsondec_err(d, "Timestamp out of range");
- }
-
- upb_Message_Set(msg, upb_MessageDef_FindFieldByNumber(m, 1), seconds,
- d->arena);
- upb_Message_Set(msg, upb_MessageDef_FindFieldByNumber(m, 2), nanos, d->arena);
- return;
-
-malformed:
- jsondec_err(d, "Malformed timestamp");
-}
-
-static void jsondec_duration(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- upb_MessageValue seconds;
- upb_MessageValue nanos;
- upb_StringView str = jsondec_string(d);
- const char* ptr = str.data;
- const char* end = ptr + str.size;
- const int64_t max = (uint64_t)3652500 * 86400;
-
- /* "3.000000001s", "3s", etc. */
- ptr = jsondec_buftoint64(d, ptr, end, &seconds.int64_val);
- nanos.int32_val = jsondec_nanos(d, &ptr, end);
-
- if (end - ptr != 1 || *ptr != 's') {
- jsondec_err(d, "Malformed duration");
- }
-
- if (seconds.int64_val < -max || seconds.int64_val > max) {
- jsondec_err(d, "Duration out of range");
- }
-
- if (seconds.int64_val < 0) {
- nanos.int32_val = -nanos.int32_val;
- }
-
- upb_Message_Set(msg, upb_MessageDef_FindFieldByNumber(m, 1), seconds,
- d->arena);
- upb_Message_Set(msg, upb_MessageDef_FindFieldByNumber(m, 2), nanos, d->arena);
-}
-
-static void jsondec_listvalue(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- const upb_FieldDef* values_f = upb_MessageDef_FindFieldByNumber(m, 1);
- const upb_MessageDef* value_m = upb_FieldDef_MessageSubDef(values_f);
- upb_Array* values = upb_Message_Mutable(msg, values_f, d->arena).array;
-
- jsondec_arrstart(d);
- while (jsondec_arrnext(d)) {
- upb_Message* value_msg = upb_Message_New(value_m, d->arena);
- upb_MessageValue value;
- value.msg_val = value_msg;
- upb_Array_Append(values, value, d->arena);
- jsondec_wellknownvalue(d, value_msg, value_m);
- }
- jsondec_arrend(d);
-}
-
-static void jsondec_struct(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- const upb_FieldDef* fields_f = upb_MessageDef_FindFieldByNumber(m, 1);
- const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(fields_f);
- const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(entry_m, 2);
- const upb_MessageDef* value_m = upb_FieldDef_MessageSubDef(value_f);
- upb_Map* fields = upb_Message_Mutable(msg, fields_f, d->arena).map;
-
- jsondec_objstart(d);
- while (jsondec_objnext(d)) {
- upb_MessageValue key, value;
- upb_Message* value_msg = upb_Message_New(value_m, d->arena);
- key.str_val = jsondec_string(d);
- value.msg_val = value_msg;
- upb_Map_Set(fields, key, value, d->arena);
- jsondec_entrysep(d);
- jsondec_wellknownvalue(d, value_msg, value_m);
- }
- jsondec_objend(d);
-}
-
-static void jsondec_wellknownvalue(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- upb_MessageValue val;
- const upb_FieldDef* f;
- upb_Message* submsg;
-
- switch (jsondec_peek(d)) {
- case JD_NUMBER:
- /* double number_value = 2; */
- f = upb_MessageDef_FindFieldByNumber(m, 2);
- val.double_val = jsondec_number(d);
- break;
- case JD_STRING:
- /* string string_value = 3; */
- f = upb_MessageDef_FindFieldByNumber(m, 3);
- val.str_val = jsondec_string(d);
- break;
- case JD_FALSE:
- /* bool bool_value = 4; */
- f = upb_MessageDef_FindFieldByNumber(m, 4);
- val.bool_val = false;
- jsondec_false(d);
- break;
- case JD_TRUE:
- /* bool bool_value = 4; */
- f = upb_MessageDef_FindFieldByNumber(m, 4);
- val.bool_val = true;
- jsondec_true(d);
- break;
- case JD_NULL:
- /* NullValue null_value = 1; */
- f = upb_MessageDef_FindFieldByNumber(m, 1);
- val.int32_val = 0;
- jsondec_null(d);
- break;
- /* Note: these cases return, because upb_Message_Mutable() is enough. */
- case JD_OBJECT:
- /* Struct struct_value = 5; */
- f = upb_MessageDef_FindFieldByNumber(m, 5);
- submsg = upb_Message_Mutable(msg, f, d->arena).msg;
- jsondec_struct(d, submsg, upb_FieldDef_MessageSubDef(f));
- return;
- case JD_ARRAY:
- /* ListValue list_value = 6; */
- f = upb_MessageDef_FindFieldByNumber(m, 6);
- submsg = upb_Message_Mutable(msg, f, d->arena).msg;
- jsondec_listvalue(d, submsg, upb_FieldDef_MessageSubDef(f));
- return;
- default:
- UPB_UNREACHABLE();
- }
-
- upb_Message_Set(msg, f, val, d->arena);
-}
-
-static upb_StringView jsondec_mask(jsondec* d, const char* buf,
- const char* end) {
- /* FieldMask fields grow due to inserted '_' characters, so we can't do the
- * transform in place. */
- const char* ptr = buf;
- upb_StringView ret;
- char* out;
-
- ret.size = end - ptr;
- while (ptr < end) {
- ret.size += (*ptr >= 'A' && *ptr <= 'Z');
- ptr++;
- }
-
- out = upb_Arena_Malloc(d->arena, ret.size);
- ptr = buf;
- ret.data = out;
-
- while (ptr < end) {
- char ch = *ptr++;
- if (ch >= 'A' && ch <= 'Z') {
- *out++ = '_';
- *out++ = ch + 32;
- } else if (ch == '_') {
- jsondec_err(d, "field mask may not contain '_'");
- } else {
- *out++ = ch;
- }
- }
-
- return ret;
-}
-
-static void jsondec_fieldmask(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- /* repeated string paths = 1; */
- const upb_FieldDef* paths_f = upb_MessageDef_FindFieldByNumber(m, 1);
- upb_Array* arr = upb_Message_Mutable(msg, paths_f, d->arena).array;
- upb_StringView str = jsondec_string(d);
- const char* ptr = str.data;
- const char* end = ptr + str.size;
- upb_MessageValue val;
-
- while (ptr < end) {
- const char* elem_end = memchr(ptr, ',', end - ptr);
- if (elem_end) {
- val.str_val = jsondec_mask(d, ptr, elem_end);
- ptr = elem_end + 1;
- } else {
- val.str_val = jsondec_mask(d, ptr, end);
- ptr = end;
- }
- upb_Array_Append(arr, val, d->arena);
- }
-}
-
-static void jsondec_anyfield(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- if (upb_MessageDef_WellKnownType(m) == kUpb_WellKnown_Unspecified) {
- /* For regular types: {"@type": "[user type]", "f1": <V1>, "f2": <V2>}
- * where f1, f2, etc. are the normal fields of this type. */
- jsondec_field(d, msg, m);
- } else {
- /* For well-known types: {"@type": "[well-known type]", "value": <X>}
- * where <X> is whatever encoding the WKT normally uses. */
- upb_StringView str = jsondec_string(d);
- jsondec_entrysep(d);
- if (!jsondec_streql(str, "value")) {
- jsondec_err(d, "Key for well-known type must be 'value'");
- }
- jsondec_wellknown(d, msg, m);
- }
-}
-
-static const upb_MessageDef* jsondec_typeurl(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- const upb_FieldDef* type_url_f = upb_MessageDef_FindFieldByNumber(m, 1);
- const upb_MessageDef* type_m;
- upb_StringView type_url = jsondec_string(d);
- const char* end = type_url.data + type_url.size;
- const char* ptr = end;
- upb_MessageValue val;
-
- val.str_val = type_url;
- upb_Message_Set(msg, type_url_f, val, d->arena);
-
- /* Find message name after the last '/' */
- while (ptr > type_url.data && *--ptr != '/') {
- }
-
- if (ptr == type_url.data || ptr == end) {
- jsondec_err(d, "Type url must have at least one '/' and non-empty host");
- }
-
- ptr++;
- type_m = upb_DefPool_FindMessageByNameWithSize(d->symtab, ptr, end - ptr);
-
- if (!type_m) {
- jsondec_err(d, "Type was not found");
- }
-
- return type_m;
-}
-
-static void jsondec_any(jsondec* d, upb_Message* msg, const upb_MessageDef* m) {
- /* string type_url = 1;
- * bytes value = 2; */
- const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(m, 2);
- upb_Message* any_msg;
- const upb_MessageDef* any_m = NULL;
- const char* pre_type_data = NULL;
- const char* pre_type_end = NULL;
- upb_MessageValue encoded;
-
- jsondec_objstart(d);
-
- /* Scan looking for "@type", which is not necessarily first. */
- while (!any_m && jsondec_objnext(d)) {
- const char* start = d->ptr;
- upb_StringView name = jsondec_string(d);
- jsondec_entrysep(d);
- if (jsondec_streql(name, "@type")) {
- any_m = jsondec_typeurl(d, msg, m);
- if (pre_type_data) {
- pre_type_end = start;
- while (*pre_type_end != ',') pre_type_end--;
- }
- } else {
- if (!pre_type_data) pre_type_data = start;
- jsondec_skipval(d);
- }
- }
-
- if (!any_m) {
- jsondec_err(d, "Any object didn't contain a '@type' field");
- }
-
- any_msg = upb_Message_New(any_m, d->arena);
-
- if (pre_type_data) {
- size_t len = pre_type_end - pre_type_data + 1;
- char* tmp = upb_Arena_Malloc(d->arena, len);
- const char* saved_ptr = d->ptr;
- const char* saved_end = d->end;
- memcpy(tmp, pre_type_data, len - 1);
- tmp[len - 1] = '}';
- d->ptr = tmp;
- d->end = tmp + len;
- d->is_first = true;
- while (jsondec_objnext(d)) {
- jsondec_anyfield(d, any_msg, any_m);
- }
- d->ptr = saved_ptr;
- d->end = saved_end;
- }
-
- while (jsondec_objnext(d)) {
- jsondec_anyfield(d, any_msg, any_m);
- }
-
- jsondec_objend(d);
-
- encoded.str_val.data = upb_Encode(any_msg, upb_MessageDef_MiniTable(any_m), 0,
- d->arena, &encoded.str_val.size);
- upb_Message_Set(msg, value_f, encoded, d->arena);
-}
-
-static void jsondec_wrapper(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(m, 1);
- upb_MessageValue val = jsondec_value(d, value_f);
- upb_Message_Set(msg, value_f, val, d->arena);
-}
-
-static void jsondec_wellknown(jsondec* d, upb_Message* msg,
- const upb_MessageDef* m) {
- switch (upb_MessageDef_WellKnownType(m)) {
- case kUpb_WellKnown_Any:
- jsondec_any(d, msg, m);
- break;
- case kUpb_WellKnown_FieldMask:
- jsondec_fieldmask(d, msg, m);
- break;
- case kUpb_WellKnown_Duration:
- jsondec_duration(d, msg, m);
- break;
- case kUpb_WellKnown_Timestamp:
- jsondec_timestamp(d, msg, m);
- break;
- case kUpb_WellKnown_Value:
- jsondec_wellknownvalue(d, msg, m);
- break;
- case kUpb_WellKnown_ListValue:
- jsondec_listvalue(d, msg, m);
- break;
- case kUpb_WellKnown_Struct:
- jsondec_struct(d, msg, m);
- break;
- case kUpb_WellKnown_DoubleValue:
- case kUpb_WellKnown_FloatValue:
- case kUpb_WellKnown_Int64Value:
- case kUpb_WellKnown_UInt64Value:
- case kUpb_WellKnown_Int32Value:
- case kUpb_WellKnown_UInt32Value:
- case kUpb_WellKnown_StringValue:
- case kUpb_WellKnown_BytesValue:
- case kUpb_WellKnown_BoolValue:
- jsondec_wrapper(d, msg, m);
- break;
- default:
- UPB_UNREACHABLE();
- }
-}
-
-bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg,
- const upb_MessageDef* m, const upb_DefPool* symtab,
- int options, upb_Arena* arena, upb_Status* status) {
- jsondec d;
-
- if (size == 0) return true;
-
- d.ptr = buf;
- d.end = buf + size;
- d.arena = arena;
- d.symtab = symtab;
- d.status = status;
- d.options = options;
- d.depth = 64;
- d.line = 1;
- d.line_begin = d.ptr;
- d.debug_field = NULL;
- d.is_first = false;
-
- if (UPB_SETJMP(d.err)) return false;
-
- jsondec_tomsg(&d, msg, m);
- return true;
-}
-
-/** upb/json_encode.c ************************************************************/
-
-#include <ctype.h>
-#include <float.h>
-#include <inttypes.h>
-#include <math.h>
-#include <setjmp.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-
-
-/* Must be last. */
-
-typedef struct {
- char *buf, *ptr, *end;
- size_t overflow;
- int indent_depth;
- int options;
- const upb_DefPool* ext_pool;
- jmp_buf err;
- upb_Status* status;
- upb_Arena* arena;
-} jsonenc;
-
-static void jsonenc_msg(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m);
-static void jsonenc_scalar(jsonenc* e, upb_MessageValue val,
- const upb_FieldDef* f);
-static void jsonenc_msgfield(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m);
-static void jsonenc_msgfields(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m, bool first);
-static void jsonenc_value(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m);
-
-UPB_NORETURN static void jsonenc_err(jsonenc* e, const char* msg) {
- upb_Status_SetErrorMessage(e->status, msg);
- longjmp(e->err, 1);
-}
-
-UPB_PRINTF(2, 3)
-UPB_NORETURN static void jsonenc_errf(jsonenc* e, const char* fmt, ...) {
- va_list argp;
- va_start(argp, fmt);
- upb_Status_VSetErrorFormat(e->status, fmt, argp);
- va_end(argp);
- longjmp(e->err, 1);
-}
-
-static upb_Arena* jsonenc_arena(jsonenc* e) {
- /* Create lazily, since it's only needed for Any */
- if (!e->arena) {
- e->arena = upb_Arena_New();
- }
- return e->arena;
-}
-
-static void jsonenc_putbytes(jsonenc* e, const void* data, size_t len) {
- size_t have = e->end - e->ptr;
- if (UPB_LIKELY(have >= len)) {
- memcpy(e->ptr, data, len);
- e->ptr += len;
- } else {
- if (have) {
- memcpy(e->ptr, data, have);
- e->ptr += have;
- }
- e->overflow += (len - have);
- }
-}
-
-static void jsonenc_putstr(jsonenc* e, const char* str) {
- jsonenc_putbytes(e, str, strlen(str));
-}
-
-UPB_PRINTF(2, 3)
-static void jsonenc_printf(jsonenc* e, const char* fmt, ...) {
- size_t n;
- size_t have = e->end - e->ptr;
- va_list args;
-
- va_start(args, fmt);
- n = vsnprintf(e->ptr, have, fmt, args);
- va_end(args);
-
- if (UPB_LIKELY(have > n)) {
- e->ptr += n;
- } else {
- e->ptr = UPB_PTRADD(e->ptr, have);
- e->overflow += (n - have);
- }
-}
-
-static void jsonenc_nanos(jsonenc* e, int32_t nanos) {
- int digits = 9;
-
- if (nanos == 0) return;
- if (nanos < 0 || nanos >= 1000000000) {
- jsonenc_err(e, "error formatting timestamp as JSON: invalid nanos");
- }
-
- while (nanos % 1000 == 0) {
- nanos /= 1000;
- digits -= 3;
- }
-
- jsonenc_printf(e, ".%.*" PRId32, digits, nanos);
-}
-
-static void jsonenc_timestamp(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m) {
- const upb_FieldDef* seconds_f = upb_MessageDef_FindFieldByNumber(m, 1);
- const upb_FieldDef* nanos_f = upb_MessageDef_FindFieldByNumber(m, 2);
- int64_t seconds = upb_Message_Get(msg, seconds_f).int64_val;
- int32_t nanos = upb_Message_Get(msg, nanos_f).int32_val;
- int L, N, I, J, K, hour, min, sec;
-
- if (seconds < -62135596800) {
- jsonenc_err(e,
- "error formatting timestamp as JSON: minimum acceptable value "
- "is 0001-01-01T00:00:00Z");
- } else if (seconds > 253402300799) {
- jsonenc_err(e,
- "error formatting timestamp as JSON: maximum acceptable value "
- "is 9999-12-31T23:59:59Z");
- }
-
- /* Julian Day -> Y/M/D, Algorithm from:
- * Fliegel, H. F., and Van Flandern, T. C., "A Machine Algorithm for
- * Processing Calendar Dates," Communications of the Association of
- * Computing Machines, vol. 11 (1968), p. 657. */
- seconds += 62135596800; // Ensure seconds is positive.
- L = (int)(seconds / 86400) - 719162 + 68569 + 2440588;
- N = 4 * L / 146097;
- L = L - (146097 * N + 3) / 4;
- I = 4000 * (L + 1) / 1461001;
- L = L - 1461 * I / 4 + 31;
- J = 80 * L / 2447;
- K = L - 2447 * J / 80;
- L = J / 11;
- J = J + 2 - 12 * L;
- I = 100 * (N - 49) + I + L;
-
- sec = seconds % 60;
- min = (seconds / 60) % 60;
- hour = (seconds / 3600) % 24;
-
- jsonenc_printf(e, "\"%04d-%02d-%02dT%02d:%02d:%02d", I, J, K, hour, min, sec);
- jsonenc_nanos(e, nanos);
- jsonenc_putstr(e, "Z\"");
-}
-
-static void jsonenc_duration(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m) {
- const upb_FieldDef* seconds_f = upb_MessageDef_FindFieldByNumber(m, 1);
- const upb_FieldDef* nanos_f = upb_MessageDef_FindFieldByNumber(m, 2);
- int64_t seconds = upb_Message_Get(msg, seconds_f).int64_val;
- int32_t nanos = upb_Message_Get(msg, nanos_f).int32_val;
-
- if (seconds > 315576000000 || seconds < -315576000000 ||
- (seconds < 0) != (nanos < 0)) {
- jsonenc_err(e, "bad duration");
- }
-
- if (nanos < 0) {
- nanos = -nanos;
- }
-
- jsonenc_printf(e, "\"%" PRId64, seconds);
- jsonenc_nanos(e, nanos);
- jsonenc_putstr(e, "s\"");
-}
-
-static void jsonenc_enum(int32_t val, const upb_FieldDef* f, jsonenc* e) {
- const upb_EnumDef* e_def = upb_FieldDef_EnumSubDef(f);
-
- if (strcmp(upb_EnumDef_FullName(e_def), "google.protobuf.NullValue") == 0) {
- jsonenc_putstr(e, "null");
- } else {
- const upb_EnumValueDef* ev = upb_EnumDef_FindValueByNumber(e_def, val);
-
- if (ev) {
- jsonenc_printf(e, "\"%s\"", upb_EnumValueDef_Name(ev));
- } else {
- jsonenc_printf(e, "%" PRId32, val);
- }
- }
-}
-
-static void jsonenc_bytes(jsonenc* e, upb_StringView str) {
- /* This is the regular base64, not the "web-safe" version. */
- static const char base64[] =
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
- const unsigned char* ptr = (unsigned char*)str.data;
- const unsigned char* end = UPB_PTRADD(ptr, str.size);
- char buf[4];
-
- jsonenc_putstr(e, "\"");
-
- while (end - ptr >= 3) {
- buf[0] = base64[ptr[0] >> 2];
- buf[1] = base64[((ptr[0] & 0x3) << 4) | (ptr[1] >> 4)];
- buf[2] = base64[((ptr[1] & 0xf) << 2) | (ptr[2] >> 6)];
- buf[3] = base64[ptr[2] & 0x3f];
- jsonenc_putbytes(e, buf, 4);
- ptr += 3;
- }
-
- switch (end - ptr) {
- case 2:
- buf[0] = base64[ptr[0] >> 2];
- buf[1] = base64[((ptr[0] & 0x3) << 4) | (ptr[1] >> 4)];
- buf[2] = base64[(ptr[1] & 0xf) << 2];
- buf[3] = '=';
- jsonenc_putbytes(e, buf, 4);
- break;
- case 1:
- buf[0] = base64[ptr[0] >> 2];
- buf[1] = base64[((ptr[0] & 0x3) << 4)];
- buf[2] = '=';
- buf[3] = '=';
- jsonenc_putbytes(e, buf, 4);
- break;
- }
-
- jsonenc_putstr(e, "\"");
-}
-
-static void jsonenc_stringbody(jsonenc* e, upb_StringView str) {
- const char* ptr = str.data;
- const char* end = UPB_PTRADD(ptr, str.size);
-
- while (ptr < end) {
- switch (*ptr) {
- case '\n':
- jsonenc_putstr(e, "\\n");
- break;
- case '\r':
- jsonenc_putstr(e, "\\r");
- break;
- case '\t':
- jsonenc_putstr(e, "\\t");
- break;
- case '\"':
- jsonenc_putstr(e, "\\\"");
- break;
- case '\f':
- jsonenc_putstr(e, "\\f");
- break;
- case '\b':
- jsonenc_putstr(e, "\\b");
- break;
- case '\\':
- jsonenc_putstr(e, "\\\\");
- break;
- default:
- if ((uint8_t)*ptr < 0x20) {
- jsonenc_printf(e, "\\u%04x", (int)(uint8_t)*ptr);
- } else {
- /* This could be a non-ASCII byte. We rely on the string being valid
- * UTF-8. */
- jsonenc_putbytes(e, ptr, 1);
- }
- break;
- }
- ptr++;
- }
-}
-
-static void jsonenc_string(jsonenc* e, upb_StringView str) {
- jsonenc_putstr(e, "\"");
- jsonenc_stringbody(e, str);
- jsonenc_putstr(e, "\"");
-}
-
-static bool upb_JsonEncode_HandleSpecialDoubles(jsonenc* e, double val) {
- if (val == INFINITY) {
- jsonenc_putstr(e, "\"Infinity\"");
- } else if (val == -INFINITY) {
- jsonenc_putstr(e, "\"-Infinity\"");
- } else if (val != val) {
- jsonenc_putstr(e, "\"NaN\"");
- } else {
- return false;
- }
- return true;
-}
-
-static void upb_JsonEncode_Double(jsonenc* e, double val) {
- if (upb_JsonEncode_HandleSpecialDoubles(e, val)) return;
- char buf[32];
- _upb_EncodeRoundTripDouble(val, buf, sizeof(buf));
- jsonenc_putstr(e, buf);
-}
-
-static void upb_JsonEncode_Float(jsonenc* e, float val) {
- if (upb_JsonEncode_HandleSpecialDoubles(e, val)) return;
- char buf[32];
- _upb_EncodeRoundTripFloat(val, buf, sizeof(buf));
- jsonenc_putstr(e, buf);
-}
-
-static void jsonenc_wrapper(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m) {
- const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(m, 1);
- upb_MessageValue val = upb_Message_Get(msg, val_f);
- jsonenc_scalar(e, val, val_f);
-}
-
-static const upb_MessageDef* jsonenc_getanymsg(jsonenc* e,
- upb_StringView type_url) {
- /* Find last '/', if any. */
- const char* end = type_url.data + type_url.size;
- const char* ptr = end;
- const upb_MessageDef* ret;
-
- if (!e->ext_pool) {
- jsonenc_err(e, "Tried to encode Any, but no symtab was provided");
- }
-
- if (type_url.size == 0) goto badurl;
-
- while (true) {
- if (--ptr == type_url.data) {
- /* Type URL must contain at least one '/', with host before. */
- goto badurl;
- }
- if (*ptr == '/') {
- ptr++;
- break;
- }
- }
-
- ret = upb_DefPool_FindMessageByNameWithSize(e->ext_pool, ptr, end - ptr);
-
- if (!ret) {
- jsonenc_errf(e, "Couldn't find Any type: %.*s", (int)(end - ptr), ptr);
- }
-
- return ret;
-
-badurl:
- jsonenc_errf(e, "Bad type URL: " UPB_STRINGVIEW_FORMAT,
- UPB_STRINGVIEW_ARGS(type_url));
-}
-
-static void jsonenc_any(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m) {
- const upb_FieldDef* type_url_f = upb_MessageDef_FindFieldByNumber(m, 1);
- const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(m, 2);
- upb_StringView type_url = upb_Message_Get(msg, type_url_f).str_val;
- upb_StringView value = upb_Message_Get(msg, value_f).str_val;
- const upb_MessageDef* any_m = jsonenc_getanymsg(e, type_url);
- const upb_MiniTable* any_layout = upb_MessageDef_MiniTable(any_m);
- upb_Arena* arena = jsonenc_arena(e);
- upb_Message* any = upb_Message_New(any_m, arena);
-
- if (upb_Decode(value.data, value.size, any, any_layout, NULL, 0, arena) !=
- kUpb_DecodeStatus_Ok) {
- jsonenc_err(e, "Error decoding message in Any");
- }
-
- jsonenc_putstr(e, "{\"@type\":");
- jsonenc_string(e, type_url);
-
- if (upb_MessageDef_WellKnownType(any_m) == kUpb_WellKnown_Unspecified) {
- /* Regular messages: {"@type": "...","foo": 1, "bar": 2} */
- jsonenc_msgfields(e, any, any_m, false);
- } else {
- /* Well-known type: {"@type": "...","value": <well-known encoding>} */
- jsonenc_putstr(e, ",\"value\":");
- jsonenc_msgfield(e, any, any_m);
- }
-
- jsonenc_putstr(e, "}");
-}
-
-static void jsonenc_putsep(jsonenc* e, const char* str, bool* first) {
- if (*first) {
- *first = false;
- } else {
- jsonenc_putstr(e, str);
- }
-}
-
-static void jsonenc_fieldpath(jsonenc* e, upb_StringView path) {
- const char* ptr = path.data;
- const char* end = ptr + path.size;
-
- while (ptr < end) {
- char ch = *ptr;
-
- if (ch >= 'A' && ch <= 'Z') {
- jsonenc_err(e, "Field mask element may not have upper-case letter.");
- } else if (ch == '_') {
- if (ptr == end - 1 || *(ptr + 1) < 'a' || *(ptr + 1) > 'z') {
- jsonenc_err(e, "Underscore must be followed by a lowercase letter.");
- }
- ch = *++ptr - 32;
- }
-
- jsonenc_putbytes(e, &ch, 1);
- ptr++;
- }
-}
-
-static void jsonenc_fieldmask(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m) {
- const upb_FieldDef* paths_f = upb_MessageDef_FindFieldByNumber(m, 1);
- const upb_Array* paths = upb_Message_Get(msg, paths_f).array_val;
- bool first = true;
- size_t i, n = 0;
-
- if (paths) n = upb_Array_Size(paths);
-
- jsonenc_putstr(e, "\"");
-
- for (i = 0; i < n; i++) {
- jsonenc_putsep(e, ",", &first);
- jsonenc_fieldpath(e, upb_Array_Get(paths, i).str_val);
- }
-
- jsonenc_putstr(e, "\"");
-}
-
-static void jsonenc_struct(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m) {
- const upb_FieldDef* fields_f = upb_MessageDef_FindFieldByNumber(m, 1);
- const upb_Map* fields = upb_Message_Get(msg, fields_f).map_val;
- const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(fields_f);
- const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(entry_m, 2);
- size_t iter = kUpb_Map_Begin;
- bool first = true;
-
- jsonenc_putstr(e, "{");
-
- if (fields) {
- while (upb_MapIterator_Next(fields, &iter)) {
- upb_MessageValue key = upb_MapIterator_Key(fields, iter);
- upb_MessageValue val = upb_MapIterator_Value(fields, iter);
-
- jsonenc_putsep(e, ",", &first);
- jsonenc_string(e, key.str_val);
- jsonenc_putstr(e, ":");
- jsonenc_value(e, val.msg_val, upb_FieldDef_MessageSubDef(value_f));
- }
- }
-
- jsonenc_putstr(e, "}");
-}
-
-static void jsonenc_listvalue(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m) {
- const upb_FieldDef* values_f = upb_MessageDef_FindFieldByNumber(m, 1);
- const upb_MessageDef* values_m = upb_FieldDef_MessageSubDef(values_f);
- const upb_Array* values = upb_Message_Get(msg, values_f).array_val;
- size_t i;
- bool first = true;
-
- jsonenc_putstr(e, "[");
-
- if (values) {
- const size_t size = upb_Array_Size(values);
- for (i = 0; i < size; i++) {
- upb_MessageValue elem = upb_Array_Get(values, i);
-
- jsonenc_putsep(e, ",", &first);
- jsonenc_value(e, elem.msg_val, values_m);
- }
- }
-
- jsonenc_putstr(e, "]");
-}
-
-static void jsonenc_value(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m) {
- /* TODO(haberman): do we want a reflection method to get oneof case? */
- size_t iter = kUpb_Message_Begin;
- const upb_FieldDef* f;
- upb_MessageValue val;
-
- if (!upb_Message_Next(msg, m, NULL, &f, &val, &iter)) {
- jsonenc_err(e, "No value set in Value proto");
- }
-
- switch (upb_FieldDef_Number(f)) {
- case 1:
- jsonenc_putstr(e, "null");
- break;
- case 2:
- upb_JsonEncode_Double(e, val.double_val);
- break;
- case 3:
- jsonenc_string(e, val.str_val);
- break;
- case 4:
- jsonenc_putstr(e, val.bool_val ? "true" : "false");
- break;
- case 5:
- jsonenc_struct(e, val.msg_val, upb_FieldDef_MessageSubDef(f));
- break;
- case 6:
- jsonenc_listvalue(e, val.msg_val, upb_FieldDef_MessageSubDef(f));
- break;
- }
-}
-
-static void jsonenc_msgfield(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m) {
- switch (upb_MessageDef_WellKnownType(m)) {
- case kUpb_WellKnown_Unspecified:
- jsonenc_msg(e, msg, m);
- break;
- case kUpb_WellKnown_Any:
- jsonenc_any(e, msg, m);
- break;
- case kUpb_WellKnown_FieldMask:
- jsonenc_fieldmask(e, msg, m);
- break;
- case kUpb_WellKnown_Duration:
- jsonenc_duration(e, msg, m);
- break;
- case kUpb_WellKnown_Timestamp:
- jsonenc_timestamp(e, msg, m);
- break;
- case kUpb_WellKnown_DoubleValue:
- case kUpb_WellKnown_FloatValue:
- case kUpb_WellKnown_Int64Value:
- case kUpb_WellKnown_UInt64Value:
- case kUpb_WellKnown_Int32Value:
- case kUpb_WellKnown_UInt32Value:
- case kUpb_WellKnown_StringValue:
- case kUpb_WellKnown_BytesValue:
- case kUpb_WellKnown_BoolValue:
- jsonenc_wrapper(e, msg, m);
- break;
- case kUpb_WellKnown_Value:
- jsonenc_value(e, msg, m);
- break;
- case kUpb_WellKnown_ListValue:
- jsonenc_listvalue(e, msg, m);
- break;
- case kUpb_WellKnown_Struct:
- jsonenc_struct(e, msg, m);
- break;
- }
-}
-
-static void jsonenc_scalar(jsonenc* e, upb_MessageValue val,
- const upb_FieldDef* f) {
- switch (upb_FieldDef_CType(f)) {
- case kUpb_CType_Bool:
- jsonenc_putstr(e, val.bool_val ? "true" : "false");
- break;
- case kUpb_CType_Float:
- upb_JsonEncode_Float(e, val.float_val);
- break;
- case kUpb_CType_Double:
- upb_JsonEncode_Double(e, val.double_val);
- break;
- case kUpb_CType_Int32:
- jsonenc_printf(e, "%" PRId32, val.int32_val);
- break;
- case kUpb_CType_UInt32:
- jsonenc_printf(e, "%" PRIu32, val.uint32_val);
- break;
- case kUpb_CType_Int64:
- jsonenc_printf(e, "\"%" PRId64 "\"", val.int64_val);
- break;
- case kUpb_CType_UInt64:
- jsonenc_printf(e, "\"%" PRIu64 "\"", val.uint64_val);
- break;
- case kUpb_CType_String:
- jsonenc_string(e, val.str_val);
- break;
- case kUpb_CType_Bytes:
- jsonenc_bytes(e, val.str_val);
- break;
- case kUpb_CType_Enum:
- jsonenc_enum(val.int32_val, f, e);
- break;
- case kUpb_CType_Message:
- jsonenc_msgfield(e, val.msg_val, upb_FieldDef_MessageSubDef(f));
- break;
- }
-}
-
-static void jsonenc_mapkey(jsonenc* e, upb_MessageValue val,
- const upb_FieldDef* f) {
- jsonenc_putstr(e, "\"");
-
- switch (upb_FieldDef_CType(f)) {
- case kUpb_CType_Bool:
- jsonenc_putstr(e, val.bool_val ? "true" : "false");
- break;
- case kUpb_CType_Int32:
- jsonenc_printf(e, "%" PRId32, val.int32_val);
- break;
- case kUpb_CType_UInt32:
- jsonenc_printf(e, "%" PRIu32, val.uint32_val);
- break;
- case kUpb_CType_Int64:
- jsonenc_printf(e, "%" PRId64, val.int64_val);
- break;
- case kUpb_CType_UInt64:
- jsonenc_printf(e, "%" PRIu64, val.uint64_val);
- break;
- case kUpb_CType_String:
- jsonenc_stringbody(e, val.str_val);
- break;
- default:
- UPB_UNREACHABLE();
- }
-
- jsonenc_putstr(e, "\":");
-}
-
-static void jsonenc_array(jsonenc* e, const upb_Array* arr,
- const upb_FieldDef* f) {
- size_t i;
- size_t size = arr ? upb_Array_Size(arr) : 0;
- bool first = true;
-
- jsonenc_putstr(e, "[");
-
- for (i = 0; i < size; i++) {
- jsonenc_putsep(e, ",", &first);
- jsonenc_scalar(e, upb_Array_Get(arr, i), f);
- }
-
- jsonenc_putstr(e, "]");
-}
-
-static void jsonenc_map(jsonenc* e, const upb_Map* map, const upb_FieldDef* f) {
- const upb_MessageDef* entry = upb_FieldDef_MessageSubDef(f);
- const upb_FieldDef* key_f = upb_MessageDef_FindFieldByNumber(entry, 1);
- const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(entry, 2);
- size_t iter = kUpb_Map_Begin;
- bool first = true;
-
- jsonenc_putstr(e, "{");
-
- if (map) {
- while (upb_MapIterator_Next(map, &iter)) {
- jsonenc_putsep(e, ",", &first);
- jsonenc_mapkey(e, upb_MapIterator_Key(map, iter), key_f);
- jsonenc_scalar(e, upb_MapIterator_Value(map, iter), val_f);
- }
- }
-
- jsonenc_putstr(e, "}");
-}
-
-static void jsonenc_fieldval(jsonenc* e, const upb_FieldDef* f,
- upb_MessageValue val, bool* first) {
- const char* name;
-
- jsonenc_putsep(e, ",", first);
-
- if (upb_FieldDef_IsExtension(f)) {
- // TODO: For MessageSet, I would have expected this to print the message
- // name here, but Python doesn't appear to do this. We should do more
- // research here about what various implementations do.
- jsonenc_printf(e, "\"[%s]\":", upb_FieldDef_FullName(f));
- } else {
- if (e->options & upb_JsonEncode_UseProtoNames) {
- name = upb_FieldDef_Name(f);
- } else {
- name = upb_FieldDef_JsonName(f);
- }
- jsonenc_printf(e, "\"%s\":", name);
- }
-
- if (upb_FieldDef_IsMap(f)) {
- jsonenc_map(e, val.map_val, f);
- } else if (upb_FieldDef_IsRepeated(f)) {
- jsonenc_array(e, val.array_val, f);
- } else {
- jsonenc_scalar(e, val, f);
- }
-}
-
-static void jsonenc_msgfields(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m, bool first) {
- upb_MessageValue val;
- const upb_FieldDef* f;
-
- if (e->options & upb_JsonEncode_EmitDefaults) {
- /* Iterate over all fields. */
- int i = 0;
- int n = upb_MessageDef_FieldCount(m);
- for (i = 0; i < n; i++) {
- f = upb_MessageDef_Field(m, i);
- if (!upb_FieldDef_HasPresence(f) || upb_Message_Has(msg, f)) {
- jsonenc_fieldval(e, f, upb_Message_Get(msg, f), &first);
- }
- }
- } else {
- /* Iterate over non-empty fields. */
- size_t iter = kUpb_Message_Begin;
- while (upb_Message_Next(msg, m, e->ext_pool, &f, &val, &iter)) {
- jsonenc_fieldval(e, f, val, &first);
- }
- }
-}
-
-static void jsonenc_msg(jsonenc* e, const upb_Message* msg,
- const upb_MessageDef* m) {
- jsonenc_putstr(e, "{");
- jsonenc_msgfields(e, msg, m, true);
- jsonenc_putstr(e, "}");
-}
-
-static size_t jsonenc_nullz(jsonenc* e, size_t size) {
- size_t ret = e->ptr - e->buf + e->overflow;
-
- if (size > 0) {
- if (e->ptr == e->end) e->ptr--;
- *e->ptr = '\0';
- }
-
- return ret;
-}
-
-size_t upb_JsonEncode(const upb_Message* msg, const upb_MessageDef* m,
- const upb_DefPool* ext_pool, int options, char* buf,
- size_t size, upb_Status* status) {
- jsonenc e;
-
- e.buf = buf;
- e.ptr = buf;
- e.end = UPB_PTRADD(buf, size);
- e.overflow = 0;
- e.options = options;
- e.ext_pool = ext_pool;
- e.status = status;
- e.arena = NULL;
-
- if (setjmp(e.err)) return -1;
-
- jsonenc_msgfield(&e, msg, m);
- if (e.arena) upb_Arena_Free(e.arena);
- return jsonenc_nullz(&e, size);
+ return 0;
}
-/** upb/port_undef.inc ************************************************************/
/* See port_def.inc. This should #undef all macros #defined there. */
#undef UPB_SIZE
@@ -11090,6 +12647,7 @@
#undef UPB_ALIGN_DOWN
#undef UPB_ALIGN_MALLOC
#undef UPB_ALIGN_OF
+#undef UPB_MALLOC_ALIGN
#undef UPB_LIKELY
#undef UPB_UNLIKELY
#undef UPB_FORCEINLINE
@@ -11113,3 +12671,5 @@
#undef UPB_UNPOISON_MEMORY_REGION
#undef UPB_ASAN
#undef UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3
+#undef UPB_DEPRECATED
+#undef UPB_GNUC_MIN
diff --git a/ruby/ext/google/protobuf_c/ruby-upb.h b/ruby/ext/google/protobuf_c/ruby-upb.h
index e57eb0e..a218a97 100755
--- a/ruby/ext/google/protobuf_c/ruby-upb.h
+++ b/ruby/ext/google/protobuf_c/ruby-upb.h
@@ -1,32 +1,6 @@
// Ruby is still using proto3 enum semantics for proto2
#define UPB_DISABLE_PROTO2_ENUM_CHECKING
/* Amalgamated source file */
-/*
- * Copyright (c) 2009-2021, Google LLC
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of Google LLC nor the
- * names of its contributors may be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
/*
* This is where we define macros used across upb.
@@ -57,8 +31,20 @@
#error upb requires C99 or C++11 or MSVC >= 2015.
#endif
-#include <stdint.h>
+// Portable check for GCC minimum version:
+// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
+#define UPB_GNUC_MIN(x, y) \
+ (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
+#else
+#define UPB_GNUC_MIN(x, y) 0
+#endif
+
+#include <assert.h>
+#include <setjmp.h>
+#include <stdbool.h>
#include <stddef.h>
+#include <stdint.h>
#if UINTPTR_MAX == 0xffffffff
#define UPB_SIZE(size32, size64) size32
@@ -91,9 +77,10 @@
#define UPB_INLINE static
#endif
+#define UPB_MALLOC_ALIGN 8
#define UPB_ALIGN_UP(size, align) (((size) + (align) - 1) / (align) * (align))
#define UPB_ALIGN_DOWN(size, align) ((size) / (align) * (align))
-#define UPB_ALIGN_MALLOC(size) UPB_ALIGN_UP(size, 16)
+#define UPB_ALIGN_MALLOC(size) UPB_ALIGN_UP(size, UPB_MALLOC_ALIGN)
#define UPB_ALIGN_OF(type) offsetof (struct { char c; type member; }, member)
/* Hints to the compiler about likely/unlikely branches. */
@@ -231,7 +218,11 @@
#undef UPB_FASTTABLE_SUPPORTED
-/* ASAN poisoning (for arena) *************************************************/
+/* ASAN poisoning (for arena).
+ * If using UPB from an interpreted language like Ruby, a build of the
+ * interpreter compiled with ASAN enbabled must be used in order to get sane and
+ * expected behavior.
+ */
#if defined(__SANITIZE_ADDRESS__)
#define UPB_ASAN 1
@@ -263,16 +254,35 @@
#define UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3 0
#endif
-/** upb/decode.h ************************************************************/
-/*
- * upb_decode: parsing into a upb_Message using a upb_MiniTable.
- */
+#if defined(__cplusplus)
+#if defined(__clang__) || UPB_GNUC_MIN(6, 0)
+// https://gcc.gnu.org/gcc-6/changes.html
+#if __cplusplus >= 201402L
+#define UPB_DEPRECATED [[deprecated]]
+#else
+#define UPB_DEPRECATED __attribute__((deprecated))
+#endif
+#else
+#define UPB_DEPRECATED
+#endif
+#else
+#define UPB_DEPRECATED
+#endif
-#ifndef UPB_DECODE_H_
-#define UPB_DECODE_H_
+#ifndef UPB_INTERNAL_ARRAY_H_
+#define UPB_INTERNAL_ARRAY_H_
+
+#include <string.h>
-/** upb/msg.h ************************************************************/
+#ifndef UPB_ARRAY_H_
+#define UPB_ARRAY_H_
+
+
+#ifndef UPB_MESSAGE_VALUE_H_
+#define UPB_MESSAGE_VALUE_H_
+
+
/*
* Public APIs for message operations that do not require descriptors.
* These functions can be used even in build that does not want to depend on
@@ -284,52 +294,256 @@
#ifndef UPB_MSG_H_
#define UPB_MSG_H_
-#include <stddef.h>
+#ifndef UPB_ARENA_H_
+#define UPB_ARENA_H_
-/** upb/upb.h ************************************************************/
-/*
- * This file contains shared definitions that are widely used across upb.
- */
-
-#ifndef UPB_H_
-#define UPB_H_
-
-#include <assert.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
#include <string.h>
+#ifndef UPB_ALLOC_H_
+#define UPB_ALLOC_H_
+
+// Must be last.
+
#ifdef __cplusplus
extern "C" {
#endif
-/* upb_Status *****************************************************************/
+typedef struct upb_alloc upb_alloc;
-#define _kUpb_Status_MaxMessage 127
+/* A combined `malloc()`/`free()` function.
+ * If `size` is 0 then the function acts like `free()`, otherwise it acts like
+ * `realloc()`. Only `oldsize` bytes from a previous allocation are
+ * preserved. */
+typedef void* upb_alloc_func(upb_alloc* alloc, void* ptr, size_t oldsize,
+ size_t size);
+
+/* A upb_alloc is a possibly-stateful allocator object.
+ *
+ * It could either be an arena allocator (which doesn't require individual
+ * `free()` calls) or a regular `malloc()` (which does). The client must
+ * therefore free memory unless it knows that the allocator is an arena
+ * allocator. */
+struct upb_alloc {
+ upb_alloc_func* func;
+};
+
+UPB_INLINE void* upb_malloc(upb_alloc* alloc, size_t size) {
+ UPB_ASSERT(alloc);
+ return alloc->func(alloc, NULL, 0, size);
+}
+
+UPB_INLINE void* upb_realloc(upb_alloc* alloc, void* ptr, size_t oldsize,
+ size_t size) {
+ UPB_ASSERT(alloc);
+ return alloc->func(alloc, ptr, oldsize, size);
+}
+
+UPB_INLINE void upb_free(upb_alloc* alloc, void* ptr) {
+ UPB_ASSERT(alloc);
+ alloc->func(alloc, ptr, 0, 0);
+}
+
+/* The global allocator used by upb. Uses the standard malloc()/free(). */
+
+extern upb_alloc upb_alloc_global;
+
+/* Functions that hard-code the global malloc.
+ *
+ * We still get benefit because we can put custom logic into our global
+ * allocator, like injecting out-of-memory faults in debug/testing builds. */
+
+UPB_INLINE void* upb_gmalloc(size_t size) {
+ return upb_malloc(&upb_alloc_global, size);
+}
+
+UPB_INLINE void* upb_grealloc(void* ptr, size_t oldsize, size_t size) {
+ return upb_realloc(&upb_alloc_global, ptr, oldsize, size);
+}
+
+UPB_INLINE void upb_gfree(void* ptr) { upb_free(&upb_alloc_global, ptr); }
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_ALLOC_H_ */
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* upb_Arena is a specific allocator implementation that uses arena allocation.
+ * The user provides an allocator that will be used to allocate the underlying
+ * arena blocks. Arenas by nature do not require the individual allocations
+ * to be freed. However the Arena does allow users to register cleanup
+ * functions that will run when the arena is destroyed.
+ *
+ * A upb_Arena is *not* thread-safe.
+ *
+ * You could write a thread-safe arena allocator that satisfies the
+ * upb_alloc interface, but it would not be as efficient for the
+ * single-threaded case. */
+
+typedef void upb_CleanupFunc(void* ud);
+
+typedef struct upb_Arena upb_Arena;
typedef struct {
- bool ok;
- char msg[_kUpb_Status_MaxMessage]; /* Error message; NULL-terminated. */
-} upb_Status;
+ /* We implement the allocator interface.
+ * This must be the first member of upb_Arena!
+ * TODO(haberman): remove once handlers are gone. */
+ upb_alloc alloc;
-const char* upb_Status_ErrorMessage(const upb_Status* status);
-bool upb_Status_IsOk(const upb_Status* status);
+ char *ptr, *end;
+} _upb_ArenaHead;
-/* These are no-op if |status| is NULL. */
-void upb_Status_Clear(upb_Status* status);
-void upb_Status_SetErrorMessage(upb_Status* status, const char* msg);
-void upb_Status_SetErrorFormat(upb_Status* status, const char* fmt, ...)
- UPB_PRINTF(2, 3);
-void upb_Status_VSetErrorFormat(upb_Status* status, const char* fmt,
- va_list args) UPB_PRINTF(2, 0);
-void upb_Status_VAppendErrorFormat(upb_Status* status, const char* fmt,
- va_list args) UPB_PRINTF(2, 0);
+/* Creates an arena from the given initial block (if any -- n may be 0).
+ * Additional blocks will be allocated from |alloc|. If |alloc| is NULL, this
+ * is a fixed-size arena and cannot grow. */
+upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc);
+void upb_Arena_Free(upb_Arena* a);
+bool upb_Arena_AddCleanup(upb_Arena* a, void* ud, upb_CleanupFunc* func);
+bool upb_Arena_Fuse(upb_Arena* a, upb_Arena* b);
+void* _upb_Arena_SlowMalloc(upb_Arena* a, size_t size);
+size_t upb_Arena_SpaceAllocated(upb_Arena* arena);
+uint32_t upb_Arena_DebugRefCount(upb_Arena* arena);
-/** upb_StringView ************************************************************/
+UPB_INLINE upb_alloc* upb_Arena_Alloc(upb_Arena* a) { return (upb_alloc*)a; }
+
+UPB_INLINE size_t _upb_ArenaHas(upb_Arena* a) {
+ _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+ return (size_t)(h->end - h->ptr);
+}
+
+UPB_INLINE void* _upb_Arena_FastMalloc(upb_Arena* a, size_t size) {
+ _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+ void* ret = h->ptr;
+ UPB_ASSERT(UPB_ALIGN_MALLOC((uintptr_t)ret) == (uintptr_t)ret);
+ UPB_ASSERT(UPB_ALIGN_MALLOC(size) == size);
+ UPB_UNPOISON_MEMORY_REGION(ret, size);
+
+ h->ptr += size;
+
+#if UPB_ASAN
+ {
+ size_t guard_size = 32;
+ if (_upb_ArenaHas(a) >= guard_size) {
+ h->ptr += guard_size;
+ } else {
+ h->ptr = h->end;
+ }
+ }
+#endif
+
+ return ret;
+}
+
+UPB_INLINE void* upb_Arena_Malloc(upb_Arena* a, size_t size) {
+ size = UPB_ALIGN_MALLOC(size);
+
+ if (UPB_UNLIKELY(_upb_ArenaHas(a) < size)) {
+ return _upb_Arena_SlowMalloc(a, size);
+ }
+
+ return _upb_Arena_FastMalloc(a, size);
+}
+
+// Shrinks the last alloc from arena.
+// REQUIRES: (ptr, oldsize) was the last malloc/realloc from this arena.
+// We could also add a upb_Arena_TryShrinkLast() which is simply a no-op if
+// this was not the last alloc.
+UPB_INLINE void upb_Arena_ShrinkLast(upb_Arena* a, void* ptr, size_t oldsize,
+ size_t size) {
+ _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+ oldsize = UPB_ALIGN_MALLOC(oldsize);
+ size = UPB_ALIGN_MALLOC(size);
+ UPB_ASSERT((char*)ptr + oldsize == h->ptr); // Must be the last alloc.
+ UPB_ASSERT(size <= oldsize);
+ h->ptr = (char*)ptr + size;
+}
+
+UPB_INLINE void* upb_Arena_Realloc(upb_Arena* a, void* ptr, size_t oldsize,
+ size_t size) {
+ _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+ oldsize = UPB_ALIGN_MALLOC(oldsize);
+ size = UPB_ALIGN_MALLOC(size);
+ bool is_most_recent_alloc = (uintptr_t)ptr + oldsize == (uintptr_t)h->ptr;
+
+ if (is_most_recent_alloc) {
+ ptrdiff_t diff = size - oldsize;
+ if ((ptrdiff_t)_upb_ArenaHas(a) >= diff) {
+ h->ptr += diff;
+ return ptr;
+ }
+ } else if (size <= oldsize) {
+ return ptr;
+ }
+
+ void* ret = upb_Arena_Malloc(a, size);
+
+ if (ret && oldsize > 0) {
+ memcpy(ret, ptr, UPB_MIN(oldsize, size));
+ }
+
+ return ret;
+}
+
+UPB_INLINE upb_Arena* upb_Arena_New(void) {
+ return upb_Arena_Init(NULL, 0, &upb_alloc_global);
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_ARENA_H_ */
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void upb_Message;
+
+/* For users these are opaque. They can be obtained from
+ * upb_MessageDef_MiniTable() but users cannot access any of the members. */
+typedef struct upb_MiniTable upb_MiniTable;
+
+/* Adds unknown data (serialized protobuf data) to the given message. The data
+ * is copied into the message instance. */
+void upb_Message_AddUnknown(upb_Message* msg, const char* data, size_t len,
+ upb_Arena* arena);
+
+/* Returns a reference to the message's unknown data. */
+const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len);
+
+/* Returns the number of extensions present in this message. */
+size_t upb_Message_ExtensionCount(const upb_Message* msg);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_MSG_INT_H_ */
+
+#ifndef UPB_STRING_VIEW_H_
+#define UPB_STRING_VIEW_H_
+
+#include <string.h>
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
typedef struct {
const char* data;
@@ -358,171 +572,77 @@
#define UPB_STRINGVIEW_FORMAT "%.*s"
#define UPB_STRINGVIEW_ARGS(view) (int)(view).size, (view).data
-/** upb_alloc *****************************************************************/
-
-/* A upb_alloc is a possibly-stateful allocator object.
- *
- * It could either be an arena allocator (which doesn't require individual
- * free() calls) or a regular malloc() (which does). The client must therefore
- * free memory unless it knows that the allocator is an arena allocator. */
-
-struct upb_alloc;
-typedef struct upb_alloc upb_alloc;
-
-/* A malloc()/free() function.
- * If "size" is 0 then the function acts like free(), otherwise it acts like
- * realloc(). Only "oldsize" bytes from a previous allocation are preserved. */
-typedef void* upb_alloc_func(upb_alloc* alloc, void* ptr, size_t oldsize,
- size_t size);
-
-struct upb_alloc {
- upb_alloc_func* func;
-};
-
-UPB_INLINE void* upb_malloc(upb_alloc* alloc, size_t size) {
- UPB_ASSERT(alloc);
- return alloc->func(alloc, NULL, 0, size);
-}
-
-UPB_INLINE void* upb_realloc(upb_alloc* alloc, void* ptr, size_t oldsize,
- size_t size) {
- UPB_ASSERT(alloc);
- return alloc->func(alloc, ptr, oldsize, size);
-}
-
-UPB_INLINE void upb_free(upb_alloc* alloc, void* ptr) {
- assert(alloc);
- alloc->func(alloc, ptr, 0, 0);
-}
-
-/* The global allocator used by upb. Uses the standard malloc()/free(). */
-
-extern upb_alloc upb_alloc_global;
-
-/* Functions that hard-code the global malloc.
- *
- * We still get benefit because we can put custom logic into our global
- * allocator, like injecting out-of-memory faults in debug/testing builds. */
-
-UPB_INLINE void* upb_gmalloc(size_t size) {
- return upb_malloc(&upb_alloc_global, size);
-}
-
-UPB_INLINE void* upb_grealloc(void* ptr, size_t oldsize, size_t size) {
- return upb_realloc(&upb_alloc_global, ptr, oldsize, size);
-}
-
-UPB_INLINE void upb_gfree(void* ptr) { upb_free(&upb_alloc_global, ptr); }
-
-/* upb_Arena ******************************************************************/
-
-/* upb_Arena is a specific allocator implementation that uses arena allocation.
- * The user provides an allocator that will be used to allocate the underlying
- * arena blocks. Arenas by nature do not require the individual allocations
- * to be freed. However the Arena does allow users to register cleanup
- * functions that will run when the arena is destroyed.
- *
- * A upb_Arena is *not* thread-safe.
- *
- * You could write a thread-safe arena allocator that satisfies the
- * upb_alloc interface, but it would not be as efficient for the
- * single-threaded case. */
-
-typedef void upb_CleanupFunc(void* ud);
-
-struct upb_Arena;
-typedef struct upb_Arena upb_Arena;
-
-typedef struct {
- /* We implement the allocator interface.
- * This must be the first member of upb_Arena!
- * TODO(haberman): remove once handlers are gone. */
- upb_alloc alloc;
-
- char *ptr, *end;
-} _upb_ArenaHead;
-
-/* Creates an arena from the given initial block (if any -- n may be 0).
- * Additional blocks will be allocated from |alloc|. If |alloc| is NULL, this
- * is a fixed-size arena and cannot grow. */
-upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc);
-void upb_Arena_Free(upb_Arena* a);
-bool upb_Arena_AddCleanup(upb_Arena* a, void* ud, upb_CleanupFunc* func);
-bool upb_Arena_Fuse(upb_Arena* a, upb_Arena* b);
-void* _upb_Arena_SlowMalloc(upb_Arena* a, size_t size);
-
-UPB_INLINE upb_alloc* upb_Arena_Alloc(upb_Arena* a) { return (upb_alloc*)a; }
-
-UPB_INLINE size_t _upb_ArenaHas(upb_Arena* a) {
- _upb_ArenaHead* h = (_upb_ArenaHead*)a;
- return (size_t)(h->end - h->ptr);
-}
-
-UPB_INLINE void* upb_Arena_Malloc(upb_Arena* a, size_t size) {
- _upb_ArenaHead* h = (_upb_ArenaHead*)a;
- void* ret;
- size = UPB_ALIGN_MALLOC(size);
-
- if (UPB_UNLIKELY(_upb_ArenaHas(a) < size)) {
- return _upb_Arena_SlowMalloc(a, size);
- }
-
- ret = h->ptr;
- h->ptr += size;
- UPB_UNPOISON_MEMORY_REGION(ret, size);
-
-#if UPB_ASAN
- {
- size_t guard_size = 32;
- if (_upb_ArenaHas(a) >= guard_size) {
- h->ptr += guard_size;
- } else {
- h->ptr = h->end;
- }
- }
+#ifdef __cplusplus
+} /* extern "C" */
#endif
- return ret;
-}
-// Shrinks the last alloc from arena.
-// REQUIRES: (ptr, oldsize) was the last malloc/realloc from this arena.
-// We could also add a upb_Arena_TryShrinkLast() which is simply a no-op if
-// this was not the last alloc.
-UPB_INLINE void upb_Arena_ShrinkLast(upb_Arena* a, void* ptr, size_t oldsize,
- size_t size) {
- _upb_ArenaHead* h = (_upb_ArenaHead*)a;
- oldsize = UPB_ALIGN_MALLOC(oldsize);
- size = UPB_ALIGN_MALLOC(size);
- UPB_ASSERT((char*)ptr + oldsize == h->ptr); // Must be the last alloc.
- UPB_ASSERT(size <= oldsize);
- h->ptr = (char*)ptr + size;
-}
+#endif /* UPB_STRING_VIEW_H_ */
-UPB_INLINE void* upb_Arena_Realloc(upb_Arena* a, void* ptr, size_t oldsize,
- size_t size) {
- _upb_ArenaHead* h = (_upb_ArenaHead*)a;
- oldsize = UPB_ALIGN_MALLOC(oldsize);
- size = UPB_ALIGN_MALLOC(size);
- if (size <= oldsize) {
- if ((char*)ptr + oldsize == h->ptr) {
- upb_Arena_ShrinkLast(a, ptr, oldsize, size);
- }
- return ptr;
- }
+/*
+ * This file contains shared definitions that are widely used across upb.
+ */
- void* ret = upb_Arena_Malloc(a, size);
+#ifndef UPB_H_
+#define UPB_H_
- if (ret && oldsize > 0) {
- memcpy(ret, ptr, oldsize);
- }
+#include <assert.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
- return ret;
-}
+// TODO(b/232091617): Remove these and fix everything that breaks as a result.
-UPB_INLINE upb_Arena* upb_Arena_New(void) {
- return upb_Arena_Init(NULL, 0, &upb_alloc_global);
-}
+#ifndef UPB_STATUS_H_
+#define UPB_STATUS_H_
+
+#include <stdarg.h>
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define _kUpb_Status_MaxMessage 127
+
+typedef struct {
+ bool ok;
+ char msg[_kUpb_Status_MaxMessage]; /* Error message; NULL-terminated. */
+} upb_Status;
+
+const char* upb_Status_ErrorMessage(const upb_Status* status);
+bool upb_Status_IsOk(const upb_Status* status);
+
+/* These are no-op if |status| is NULL. */
+void upb_Status_Clear(upb_Status* status);
+void upb_Status_SetErrorMessage(upb_Status* status, const char* msg);
+void upb_Status_SetErrorFormat(upb_Status* status, const char* fmt, ...)
+ UPB_PRINTF(2, 3);
+void upb_Status_VSetErrorFormat(upb_Status* status, const char* fmt,
+ va_list args) UPB_PRINTF(2, 0);
+void upb_Status_VAppendErrorFormat(upb_Status* status, const char* fmt,
+ va_list args) UPB_PRINTF(2, 0);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_STATUS_H_ */
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// These types appear in circular references so we need to forward-declare them.
+// There is no obviously good place for this so let's just put it here.
+typedef struct upb_Array upb_Array;
+typedef struct upb_Map upb_Map;
/* Constants ******************************************************************/
@@ -602,8 +722,8 @@
if (_upb_IsLittleEndian()) {
return val;
} else {
- return ((uint64_t)_upb_BigEndian_Swap32(val) << 32) |
- _upb_BigEndian_Swap32(val >> 32);
+ return ((uint64_t)_upb_BigEndian_Swap32((uint32_t)val) << 32) |
+ _upb_BigEndian_Swap32((uint32_t)(val >> 32));
}
}
@@ -620,39 +740,401 @@
UPB_INLINE int _upb_Log2CeilingSize(int x) { return 1 << _upb_Log2Ceiling(x); }
-
#ifdef __cplusplus
} /* extern "C" */
#endif
+
#endif /* UPB_H_ */
+// Must be last.
+
#ifdef __cplusplus
extern "C" {
#endif
-/** upb_Message
- * *******************************************************************/
+// Definitions common to both upb_Array and upb_Map.
-typedef void upb_Message;
+typedef union {
+ bool bool_val;
+ float float_val;
+ double double_val;
+ int32_t int32_val;
+ int64_t int64_val;
+ uint32_t uint32_val;
+ uint64_t uint64_val;
+ const upb_Array* array_val;
+ const upb_Map* map_val;
+ const upb_Message* msg_val;
+ upb_StringView str_val;
+} upb_MessageValue;
-/* For users these are opaque. They can be obtained from
- * upb_MessageDef_MiniTable() but users cannot access any of the members. */
-struct upb_MiniTable;
-typedef struct upb_MiniTable upb_MiniTable;
+typedef union {
+ upb_Array* array;
+ upb_Map* map;
+ upb_Message* msg;
+} upb_MutableMessageValue;
-/* Adds unknown data (serialized protobuf data) to the given message. The data
- * is copied into the message instance. */
-void upb_Message_AddUnknown(upb_Message* msg, const char* data, size_t len,
- upb_Arena* arena);
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
-/* Returns a reference to the message's unknown data. */
-const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len);
-/* Returns the number of extensions present in this message. */
-size_t upb_Message_ExtensionCount(const upb_Message* msg);
+#endif /* UPB_MESSAGE_VALUE_H_ */
-/** upb_ExtensionRegistry *****************************************************/
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Creates a new array on the given arena that holds elements of this type. */
+upb_Array* upb_Array_New(upb_Arena* a, upb_CType type);
+
+/* Returns the number of elements in the array. */
+size_t upb_Array_Size(const upb_Array* arr);
+
+/* Returns the given element, which must be within the array's current size. */
+upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i);
+
+/* Sets the given element, which must be within the array's current size. */
+void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val);
+
+/* Appends an element to the array. Returns false on allocation failure. */
+bool upb_Array_Append(upb_Array* array, upb_MessageValue val, upb_Arena* arena);
+
+/* Moves elements within the array using memmove(). Like memmove(), the source
+ * and destination elements may be overlapping. */
+void upb_Array_Move(upb_Array* array, size_t dst_idx, size_t src_idx,
+ size_t count);
+
+/* Inserts one or more empty elements into the array. Existing elements are
+ * shifted right. The new elements have undefined state and must be set with
+ * `upb_Array_Set()`.
+ * REQUIRES: `i <= upb_Array_Size(arr)` */
+bool upb_Array_Insert(upb_Array* array, size_t i, size_t count,
+ upb_Arena* arena);
+
+/* Deletes one or more elements from the array. Existing elements are shifted
+ * left.
+ * REQUIRES: `i + count <= upb_Array_Size(arr)` */
+void upb_Array_Delete(upb_Array* array, size_t i, size_t count);
+
+/* Changes the size of a vector. New elements are initialized to empty/0.
+ * Returns false on allocation failure. */
+bool upb_Array_Resize(upb_Array* array, size_t size, upb_Arena* arena);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_ARRAY_H_ */
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Our internal representation for repeated fields. */
+struct upb_Array {
+ uintptr_t data; /* Tagged ptr: low 3 bits of ptr are lg2(elem size). */
+ size_t size; /* The number of elements in the array. */
+ size_t capacity; /* Allocated storage. Measured in elements. */
+ uint64_t junk;
+};
+
+UPB_INLINE const void* _upb_array_constptr(const upb_Array* arr) {
+ UPB_ASSERT((arr->data & 7) <= 4);
+ return (void*)(arr->data & ~(uintptr_t)7);
+}
+
+UPB_INLINE uintptr_t _upb_array_tagptr(void* ptr, int elem_size_lg2) {
+ UPB_ASSERT(elem_size_lg2 <= 4);
+ return (uintptr_t)ptr | elem_size_lg2;
+}
+
+UPB_INLINE void* _upb_array_ptr(upb_Array* arr) {
+ return (void*)_upb_array_constptr(arr);
+}
+
+UPB_INLINE uintptr_t _upb_tag_arrptr(void* ptr, int elem_size_lg2) {
+ UPB_ASSERT(elem_size_lg2 <= 4);
+ UPB_ASSERT(((uintptr_t)ptr & 7) == 0);
+ return (uintptr_t)ptr | (unsigned)elem_size_lg2;
+}
+
+UPB_INLINE upb_Array* _upb_Array_New(upb_Arena* a, size_t init_capacity,
+ int elem_size_lg2) {
+ const size_t arr_size = UPB_ALIGN_UP(sizeof(upb_Array), 8);
+ const size_t bytes = sizeof(upb_Array) + (init_capacity << elem_size_lg2);
+ upb_Array* arr = (upb_Array*)upb_Arena_Malloc(a, bytes);
+ if (!arr) return NULL;
+ arr->data = _upb_tag_arrptr(UPB_PTR_AT(arr, arr_size, void), elem_size_lg2);
+ arr->size = 0;
+ arr->capacity = init_capacity;
+ return arr;
+}
+
+/* Resizes the capacity of the array to be at least min_size. */
+bool _upb_array_realloc(upb_Array* arr, size_t min_size, upb_Arena* arena);
+
+/* Fallback functions for when the accessors require a resize. */
+void* _upb_Array_Resize_fallback(upb_Array** arr_ptr, size_t size,
+ int elem_size_lg2, upb_Arena* arena);
+bool _upb_Array_Append_fallback(upb_Array** arr_ptr, const void* value,
+ int elem_size_lg2, upb_Arena* arena);
+
+UPB_INLINE bool _upb_array_reserve(upb_Array* arr, size_t size,
+ upb_Arena* arena) {
+ if (arr->capacity < size) return _upb_array_realloc(arr, size, arena);
+ return true;
+}
+
+UPB_INLINE bool _upb_Array_Resize(upb_Array* arr, size_t size,
+ upb_Arena* arena) {
+ if (!_upb_array_reserve(arr, size, arena)) return false;
+ arr->size = size;
+ return true;
+}
+
+UPB_INLINE void _upb_array_detach(const void* msg, size_t ofs) {
+ *UPB_PTR_AT(msg, ofs, upb_Array*) = NULL;
+}
+
+UPB_INLINE const void* _upb_array_accessor(const void* msg, size_t ofs,
+ size_t* size) {
+ const upb_Array* arr = *UPB_PTR_AT(msg, ofs, const upb_Array*);
+ if (arr) {
+ if (size) *size = arr->size;
+ return _upb_array_constptr(arr);
+ } else {
+ if (size) *size = 0;
+ return NULL;
+ }
+}
+
+UPB_INLINE void* _upb_array_mutable_accessor(void* msg, size_t ofs,
+ size_t* size) {
+ upb_Array* arr = *UPB_PTR_AT(msg, ofs, upb_Array*);
+ if (arr) {
+ if (size) *size = arr->size;
+ return _upb_array_ptr(arr);
+ } else {
+ if (size) *size = 0;
+ return NULL;
+ }
+}
+
+UPB_INLINE void* _upb_Array_Resize_accessor2(void* msg, size_t ofs, size_t size,
+ int elem_size_lg2,
+ upb_Arena* arena) {
+ upb_Array** arr_ptr = UPB_PTR_AT(msg, ofs, upb_Array*);
+ upb_Array* arr = *arr_ptr;
+ if (!arr || arr->capacity < size) {
+ return _upb_Array_Resize_fallback(arr_ptr, size, elem_size_lg2, arena);
+ }
+ arr->size = size;
+ return _upb_array_ptr(arr);
+}
+
+UPB_INLINE bool _upb_Array_Append_accessor2(void* msg, size_t ofs,
+ int elem_size_lg2,
+ const void* value,
+ upb_Arena* arena) {
+ upb_Array** arr_ptr = UPB_PTR_AT(msg, ofs, upb_Array*);
+ size_t elem_size = 1 << elem_size_lg2;
+ upb_Array* arr = *arr_ptr;
+ void* ptr;
+ if (!arr || arr->size == arr->capacity) {
+ return _upb_Array_Append_fallback(arr_ptr, value, elem_size_lg2, arena);
+ }
+ ptr = _upb_array_ptr(arr);
+ memcpy(UPB_PTR_AT(ptr, arr->size * elem_size, char), value, elem_size);
+ arr->size++;
+ return true;
+}
+
+/* Used by old generated code, remove once all code has been regenerated. */
+UPB_INLINE int _upb_sizelg2(upb_CType type) {
+ switch (type) {
+ case kUpb_CType_Bool:
+ return 0;
+ case kUpb_CType_Float:
+ case kUpb_CType_Int32:
+ case kUpb_CType_UInt32:
+ case kUpb_CType_Enum:
+ return 2;
+ case kUpb_CType_Message:
+ return UPB_SIZE(2, 3);
+ case kUpb_CType_Double:
+ case kUpb_CType_Int64:
+ case kUpb_CType_UInt64:
+ return 3;
+ case kUpb_CType_String:
+ case kUpb_CType_Bytes:
+ return UPB_SIZE(3, 4);
+ }
+ UPB_UNREACHABLE();
+}
+
+UPB_INLINE void* _upb_Array_Resize_accessor(void* msg, size_t ofs, size_t size,
+ upb_CType type, upb_Arena* arena) {
+ return _upb_Array_Resize_accessor2(msg, ofs, size, _upb_sizelg2(type), arena);
+}
+
+UPB_INLINE bool _upb_Array_Append_accessor(void* msg, size_t ofs,
+ size_t elem_size, upb_CType type,
+ const void* value,
+ upb_Arena* arena) {
+ (void)elem_size;
+ return _upb_Array_Append_accessor2(msg, ofs, _upb_sizelg2(type), value,
+ arena);
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_INTERNAL_ARRAY_H_ */
+
+#ifndef UPB_INTERNAL_ATOI_H_
+#define UPB_INTERNAL_ATOI_H_
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// We use these hand-written routines instead of strto[u]l() because the "long
+// long" variants aren't in c89. Also our version allows setting a ptr limit.
+// Return the new position of the pointer after parsing the int, or NULL on
+// integer overflow.
+
+const char* upb_BufToUint64(const char* ptr, const char* end, uint64_t* val);
+const char* upb_BufToInt64(const char* ptr, const char* end, int64_t* val,
+ bool* is_neg);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_INTERNAL_ATOI_H_ */
+
+#ifndef UPB_MAP_H_
+#define UPB_MAP_H_
+
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Creates a new map on the given arena with the given key/value size. */
+upb_Map* upb_Map_New(upb_Arena* a, upb_CType key_type, upb_CType value_type);
+
+/* Returns the number of entries in the map. */
+size_t upb_Map_Size(const upb_Map* map);
+
+/* Stores a value for the given key into |*val| (or the zero value if the key is
+ * not present). Returns whether the key was present. The |val| pointer may be
+ * NULL, in which case the function tests whether the given key is present. */
+bool upb_Map_Get(const upb_Map* map, upb_MessageValue key,
+ upb_MessageValue* val);
+
+/* Removes all entries in the map. */
+void upb_Map_Clear(upb_Map* map);
+
+typedef enum {
+ // LINT.IfChange
+ kUpb_MapInsertStatus_Inserted = 0,
+ kUpb_MapInsertStatus_Replaced = 1,
+ kUpb_MapInsertStatus_OutOfMemory = 2,
+ // LINT.ThenChange(//depot/google3/third_party/upb/upb/msg_internal.h)
+} upb_MapInsertStatus;
+
+/* Sets the given key to the given value, returning whether the key was inserted
+ * or replaced. If the key was inserted, then any existing iterators will be
+ * invalidated. */
+upb_MapInsertStatus upb_Map_Insert(upb_Map* map, upb_MessageValue key,
+ upb_MessageValue val, upb_Arena* arena);
+
+/* Sets the given key to the given value. Returns false if memory allocation
+ * failed. If the key is newly inserted, then any existing iterators will be
+ * invalidated. */
+UPB_INLINE bool upb_Map_Set(upb_Map* map, upb_MessageValue key,
+ upb_MessageValue val, upb_Arena* arena) {
+ return upb_Map_Insert(map, key, val, arena) !=
+ kUpb_MapInsertStatus_OutOfMemory;
+}
+
+/* Deletes this key from the table. Returns true if the key was present. */
+bool upb_Map_Delete(upb_Map* map, upb_MessageValue key);
+
+/* Map iteration:
+ *
+ * size_t iter = kUpb_Map_Begin;
+ * while (upb_MapIterator_Next(map, &iter)) {
+ * upb_MessageValue key = upb_MapIterator_Key(map, iter);
+ * upb_MessageValue val = upb_MapIterator_Value(map, iter);
+ *
+ * // If mutating is desired.
+ * upb_MapIterator_SetValue(map, iter, value2);
+ * }
+ */
+
+/* Advances to the next entry. Returns false if no more entries are present. */
+bool upb_MapIterator_Next(const upb_Map* map, size_t* iter);
+
+/* Returns true if the iterator still points to a valid entry, or false if the
+ * iterator is past the last element. It is an error to call this function with
+ * kUpb_Map_Begin (you must call next() at least once first). */
+bool upb_MapIterator_Done(const upb_Map* map, size_t iter);
+
+/* Returns the key and value for this entry of the map. */
+upb_MessageValue upb_MapIterator_Key(const upb_Map* map, size_t iter);
+upb_MessageValue upb_MapIterator_Value(const upb_Map* map, size_t iter);
+
+/* Sets the value for this entry. The iterator must not be done, and the
+ * iterator must not have been initialized const. */
+void upb_MapIterator_SetValue(upb_Map* map, size_t iter,
+ upb_MessageValue value);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_MAP_H_ */
+
+/*
+** Our memory representation for parsing tables and messages themselves.
+** Functions in this file are used by generated code and possibly reflection.
+**
+** The definitions in this file are internal to upb.
+**/
+
+#ifndef UPB_MSG_INT_H_
+#define UPB_MSG_INT_H_
+
+#include <stdlib.h>
+#include <string.h>
+
+
+#ifndef UPB_EXTENSION_REGISTRY_H_
+#define UPB_EXTENSION_REGISTRY_H_
+
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
/* Extension registry: a dynamic data structure that stores a map of:
* (upb_MiniTable, number) -> extension info
@@ -699,95 +1181,9 @@
} /* extern "C" */
#endif
-#endif /* UPB_MSG_INT_H_ */
-/* Must be last. */
+#endif /* UPB_EXTENSION_REGISTRY_H_ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-enum {
- /* If set, strings will alias the input buffer instead of copying into the
- * arena. */
- kUpb_DecodeOption_AliasString = 1,
-
- /* If set, the parse will return failure if any message is missing any
- * required fields when the message data ends. The parse will still continue,
- * and the failure will only be reported at the end.
- *
- * IMPORTANT CAVEATS:
- *
- * 1. This can throw a false positive failure if an incomplete message is seen
- * on the wire but is later completed when the sub-message occurs again.
- * For this reason, a second pass is required to verify a failure, to be
- * truly robust.
- *
- * 2. This can return a false success if you are decoding into a message that
- * already has some sub-message fields present. If the sub-message does
- * not occur in the binary payload, we will never visit it and discover the
- * incomplete sub-message. For this reason, this check is only useful for
- * implemting ParseFromString() semantics. For MergeFromString(), a
- * post-parse validation step will always be necessary. */
- kUpb_DecodeOption_CheckRequired = 2,
-};
-
-#define UPB_DECODE_MAXDEPTH(depth) ((depth) << 16)
-
-typedef enum {
- kUpb_DecodeStatus_Ok = 0,
- kUpb_DecodeStatus_Malformed = 1, // Wire format was corrupt
- kUpb_DecodeStatus_OutOfMemory = 2, // Arena alloc failed
- kUpb_DecodeStatus_BadUtf8 = 3, // String field had bad UTF-8
- kUpb_DecodeStatus_MaxDepthExceeded = 4, // Exceeded UPB_DECODE_MAXDEPTH
-
- // kUpb_DecodeOption_CheckRequired failed (see above), but the parse otherwise
- // succeeded.
- kUpb_DecodeStatus_MissingRequired = 5,
-} upb_DecodeStatus;
-
-upb_DecodeStatus upb_Decode(const char* buf, size_t size, upb_Message* msg,
- const upb_MiniTable* l,
- const upb_ExtensionRegistry* extreg, int options,
- upb_Arena* arena);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-
-#endif /* UPB_DECODE_H_ */
-
-/** upb/decode_internal.h ************************************************************/
-/*
- * Internal implementation details of the decoder that are shared between
- * decode.c and decode_fast.c.
- */
-
-#ifndef UPB_DECODE_INT_H_
-#define UPB_DECODE_INT_H_
-
-#include <setjmp.h>
-
-#include "third_party/utf8_range/utf8_range.h"
-
-/** upb/msg_internal.h ************************************************************/
-/*
-** Our memory representation for parsing tables and messages themselves.
-** Functions in this file are used by generated code and possibly reflection.
-**
-** The definitions in this file are internal to upb.
-**/
-
-#ifndef UPB_MSG_INT_H_
-#define UPB_MSG_INT_H_
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-/** upb/table_internal.h ************************************************************/
/*
* upb_table
*
@@ -807,10 +1203,9 @@
* mode, we check this on insert and lookup.
*/
-#ifndef UPB_TABLE_H_
-#define UPB_TABLE_H_
+#ifndef UPB_INTERNAL_TABLE_H_
+#define UPB_INTERNAL_TABLE_H_
-#include <stdint.h>
#include <string.h>
@@ -976,8 +1371,8 @@
void upb_strtable_clear(upb_strtable* t);
/* Inserts the given key into the hashtable with the given value. The key must
- * not already exist in the hash table. For string tables, the key must be
- * NULL-terminated, and the table will make an internal copy of the key.
+ * not already exist in the hash table. For strtables, the key is not required
+ * to be NULL-terminated, and the table will make an internal copy of the key.
* Inttables must not insert a value of UINTPTR_MAX.
*
* If a table resize was required but memory allocation failed, false is
@@ -1142,9 +1537,9 @@
#endif
-#endif /* UPB_TABLE_H_ */
+#endif /* UPB_INTERNAL_TABLE_H_ */
-/* Must be last. */
+// Must be last.
#ifdef __cplusplus
extern "C" {
@@ -1162,6 +1557,9 @@
return (uint64_t)v;
}
+extern const float kUpb_FltInfinity;
+extern const double kUpb_Infinity;
+
/** upb_MiniTable *************************************************************/
/* upb_MiniTable represents the memory layout of a given upb_MessageDef. The
@@ -1172,20 +1570,23 @@
uint32_t number;
uint16_t offset;
int16_t presence; // If >0, hasbit_index. If <0, ~oneof_index
- uint16_t submsg_index; // undefined if descriptortype != MESSAGE/GROUP/ENUM
+ uint16_t submsg_index; // kUpb_NoSub if descriptortype != MESSAGE/GROUP/ENUM
uint8_t descriptortype;
uint8_t mode; /* upb_FieldMode | upb_LabelFlags |
(upb_FieldRep << kUpb_FieldRep_Shift) */
} upb_MiniTable_Field;
+#define kUpb_NoSub ((uint16_t)-1)
+
typedef enum {
kUpb_FieldMode_Map = 0,
kUpb_FieldMode_Array = 1,
kUpb_FieldMode_Scalar = 2,
-
- kUpb_FieldMode_Mask = 3, /* Mask to isolate the mode from upb_FieldRep. */
} upb_FieldMode;
+// Mask to isolate the upb_FieldMode from field.mode.
+#define kUpb_FieldMode_Mask 3
+
/* Extra flags on the mode field. */
typedef enum {
kUpb_LabelFlags_IsPacked = 4,
@@ -1231,23 +1632,47 @@
} _upb_FastTable_Entry;
typedef struct {
- const int32_t* values; // List of values <0 or >63
- uint64_t mask; // Bits are set for acceptable value 0 <= x < 64
- int value_count;
+ uint32_t mask_limit; // Limit enum value that can be tested with mask.
+ uint32_t value_count; // Number of values after the bitfield.
+ uint32_t data[]; // Bitmask + enumerated values follow.
} upb_MiniTable_Enum;
-UPB_INLINE bool upb_MiniTable_Enum_CheckValue(const upb_MiniTable_Enum* e,
- int32_t val) {
- uint32_t uval = (uint32_t)val;
- if (uval < 64) return e->mask & (1 << uval);
+typedef enum {
+ _kUpb_FastEnumCheck_ValueIsInEnum = 0,
+ _kUpb_FastEnumCheck_ValueIsNotInEnum = 1,
+ _kUpb_FastEnumCheck_CannotCheckFast = 2,
+} _kUpb_FastEnumCheck_Status;
+
+UPB_INLINE _kUpb_FastEnumCheck_Status
+_upb_MiniTable_CheckEnumValueFast(const upb_MiniTable_Enum* e, uint32_t val) {
+ if (UPB_UNLIKELY(val >= 64)) return _kUpb_FastEnumCheck_CannotCheckFast;
+ uint64_t mask = e->data[0] | ((uint64_t)e->data[1] << 32);
+ return (mask & (1ULL << val)) ? _kUpb_FastEnumCheck_ValueIsInEnum
+ : _kUpb_FastEnumCheck_ValueIsNotInEnum;
+}
+
+UPB_INLINE bool _upb_MiniTable_CheckEnumValueSlow(const upb_MiniTable_Enum* e,
+ uint32_t val) {
+ if (val < e->mask_limit) return e->data[val / 32] & (1ULL << (val % 32));
// OPT: binary search long lists?
- int n = e->value_count;
- for (int i = 0; i < n; i++) {
- if (e->values[i] == val) return true;
+ const uint32_t* start = &e->data[e->mask_limit / 32];
+ const uint32_t* limit = &e->data[(e->mask_limit / 32) + e->value_count];
+ for (const uint32_t* p = start; p < limit; p++) {
+ if (*p == val) return true;
}
return false;
}
+// Validates enum value against range defined by enum mini table.
+UPB_INLINE bool upb_MiniTable_Enum_CheckValue(const upb_MiniTable_Enum* e,
+ uint32_t val) {
+ _kUpb_FastEnumCheck_Status status = _upb_MiniTable_CheckEnumValueFast(e, val);
+ if (UPB_UNLIKELY(status == _kUpb_FastEnumCheck_CannotCheckFast)) {
+ return _upb_MiniTable_CheckEnumValueSlow(e, val);
+ }
+ return status == _kUpb_FastEnumCheck_ValueIsInEnum ? true : false;
+}
+
typedef union {
const struct upb_MiniTable* submsg;
const upb_MiniTable_Enum* subenum;
@@ -1269,7 +1694,7 @@
* message MessageSet {
* repeated group Item = 1 {
* required int32 type_id = 2;
- * required string message = 3;
+ * required bytes message = 3;
* }
* }
*/
@@ -1384,7 +1809,7 @@
UPB_INLINE upb_Message* _upb_Message_New_inl(const upb_MiniTable* l,
upb_Arena* a) {
size_t size = upb_msg_sizeof(l);
- void* mem = upb_Arena_Malloc(a, size);
+ void* mem = upb_Arena_Malloc(a, size + sizeof(upb_Message_Internal));
upb_Message* msg;
if (UPB_UNLIKELY(!mem)) return NULL;
msg = UPB_PTR_AT(mem, sizeof(upb_Message_Internal), upb_Message);
@@ -1433,7 +1858,7 @@
/* Adds the given extension data to the given message. |ext| is copied into the
* message instance. This logically replaces any previously-added extension with
* this number */
-upb_Message_Extension* _upb_Message_Getorcreateext(
+upb_Message_Extension* _upb_Message_GetOrCreateExtension(
upb_Message* msg, const upb_MiniTable_Extension* ext, upb_Arena* arena);
/* Returns an array of extensions for this message. Note: the array is
@@ -1515,170 +1940,18 @@
return *UPB_PTR_AT(msg, ofs, const upb_Message*) != NULL;
}
-/** upb_Array *****************************************************************/
-
-/* Our internal representation for repeated fields. */
-typedef struct {
- uintptr_t data; /* Tagged ptr: low 3 bits of ptr are lg2(elem size). */
- size_t len; /* Measured in elements. */
- size_t size; /* Measured in elements. */
- uint64_t junk;
-} upb_Array;
-
-UPB_INLINE const void* _upb_array_constptr(const upb_Array* arr) {
- UPB_ASSERT((arr->data & 7) <= 4);
- return (void*)(arr->data & ~(uintptr_t)7);
-}
-
-UPB_INLINE uintptr_t _upb_array_tagptr(void* ptr, int elem_size_lg2) {
- UPB_ASSERT(elem_size_lg2 <= 4);
- return (uintptr_t)ptr | elem_size_lg2;
-}
-
-UPB_INLINE void* _upb_array_ptr(upb_Array* arr) {
- return (void*)_upb_array_constptr(arr);
-}
-
-UPB_INLINE uintptr_t _upb_tag_arrptr(void* ptr, int elem_size_lg2) {
- UPB_ASSERT(elem_size_lg2 <= 4);
- UPB_ASSERT(((uintptr_t)ptr & 7) == 0);
- return (uintptr_t)ptr | (unsigned)elem_size_lg2;
-}
-
-UPB_INLINE upb_Array* _upb_Array_New(upb_Arena* a, size_t init_size,
- int elem_size_lg2) {
- const size_t arr_size = UPB_ALIGN_UP(sizeof(upb_Array), 8);
- const size_t bytes = sizeof(upb_Array) + (init_size << elem_size_lg2);
- upb_Array* arr = (upb_Array*)upb_Arena_Malloc(a, bytes);
- if (!arr) return NULL;
- arr->data = _upb_tag_arrptr(UPB_PTR_AT(arr, arr_size, void), elem_size_lg2);
- arr->len = 0;
- arr->size = init_size;
- return arr;
-}
-
-/* Resizes the capacity of the array to be at least min_size. */
-bool _upb_array_realloc(upb_Array* arr, size_t min_size, upb_Arena* arena);
-
-/* Fallback functions for when the accessors require a resize. */
-void* _upb_Array_Resize_fallback(upb_Array** arr_ptr, size_t size,
- int elem_size_lg2, upb_Arena* arena);
-bool _upb_Array_Append_fallback(upb_Array** arr_ptr, const void* value,
- int elem_size_lg2, upb_Arena* arena);
-
-UPB_INLINE bool _upb_array_reserve(upb_Array* arr, size_t size,
- upb_Arena* arena) {
- if (arr->size < size) return _upb_array_realloc(arr, size, arena);
- return true;
-}
-
-UPB_INLINE bool _upb_Array_Resize(upb_Array* arr, size_t size,
- upb_Arena* arena) {
- if (!_upb_array_reserve(arr, size, arena)) return false;
- arr->len = size;
- return true;
-}
-
-UPB_INLINE const void* _upb_array_accessor(const void* msg, size_t ofs,
- size_t* size) {
- const upb_Array* arr = *UPB_PTR_AT(msg, ofs, const upb_Array*);
- if (arr) {
- if (size) *size = arr->len;
- return _upb_array_constptr(arr);
- } else {
- if (size) *size = 0;
- return NULL;
- }
-}
-
-UPB_INLINE void* _upb_array_mutable_accessor(void* msg, size_t ofs,
- size_t* size) {
- upb_Array* arr = *UPB_PTR_AT(msg, ofs, upb_Array*);
- if (arr) {
- if (size) *size = arr->len;
- return _upb_array_ptr(arr);
- } else {
- if (size) *size = 0;
- return NULL;
- }
-}
-
-UPB_INLINE void* _upb_Array_Resize_accessor2(void* msg, size_t ofs, size_t size,
- int elem_size_lg2,
- upb_Arena* arena) {
- upb_Array** arr_ptr = UPB_PTR_AT(msg, ofs, upb_Array*);
- upb_Array* arr = *arr_ptr;
- if (!arr || arr->size < size) {
- return _upb_Array_Resize_fallback(arr_ptr, size, elem_size_lg2, arena);
- }
- arr->len = size;
- return _upb_array_ptr(arr);
-}
-
-UPB_INLINE bool _upb_Array_Append_accessor2(void* msg, size_t ofs,
- int elem_size_lg2,
- const void* value,
- upb_Arena* arena) {
- upb_Array** arr_ptr = UPB_PTR_AT(msg, ofs, upb_Array*);
- size_t elem_size = 1 << elem_size_lg2;
- upb_Array* arr = *arr_ptr;
- void* ptr;
- if (!arr || arr->len == arr->size) {
- return _upb_Array_Append_fallback(arr_ptr, value, elem_size_lg2, arena);
- }
- ptr = _upb_array_ptr(arr);
- memcpy(UPB_PTR_AT(ptr, arr->len * elem_size, char), value, elem_size);
- arr->len++;
- return true;
-}
-
-/* Used by old generated code, remove once all code has been regenerated. */
-UPB_INLINE int _upb_sizelg2(upb_CType type) {
- switch (type) {
- case kUpb_CType_Bool:
- return 0;
- case kUpb_CType_Float:
- case kUpb_CType_Int32:
- case kUpb_CType_UInt32:
- case kUpb_CType_Enum:
- return 2;
- case kUpb_CType_Message:
- return UPB_SIZE(2, 3);
- case kUpb_CType_Double:
- case kUpb_CType_Int64:
- case kUpb_CType_UInt64:
- return 3;
- case kUpb_CType_String:
- case kUpb_CType_Bytes:
- return UPB_SIZE(3, 4);
- }
- UPB_UNREACHABLE();
-}
-UPB_INLINE void* _upb_Array_Resize_accessor(void* msg, size_t ofs, size_t size,
- upb_CType type, upb_Arena* arena) {
- return _upb_Array_Resize_accessor2(msg, ofs, size, _upb_sizelg2(type), arena);
-}
-UPB_INLINE bool _upb_Array_Append_accessor(void* msg, size_t ofs,
- size_t elem_size, upb_CType type,
- const void* value,
- upb_Arena* arena) {
- (void)elem_size;
- return _upb_Array_Append_accessor2(msg, ofs, _upb_sizelg2(type), value,
- arena);
-}
-
/** upb_Map *******************************************************************/
/* Right now we use strmaps for everything. We'll likely want to use
* integer-specific maps for integer-keyed maps.*/
-typedef struct {
+struct upb_Map {
/* Size of key and val, based on the map type. Strings are represented as '0'
* because they must be handled specially. */
char key_size;
char val_size;
upb_strtable table;
-} upb_Map;
+};
/* Map entries aren't actually stored, they are only used during parsing. For
* parsing, it helps a lot if all map entry messages have the same layout.
@@ -1772,15 +2045,31 @@
return (void*)str_tabent(&it);
}
-UPB_INLINE bool _upb_Map_Set(upb_Map* map, const void* key, size_t key_size,
- void* val, size_t val_size, upb_Arena* a) {
+typedef enum {
+ // LINT.IfChange
+ _kUpb_MapInsertStatus_Inserted = 0,
+ _kUpb_MapInsertStatus_Replaced = 1,
+ _kUpb_MapInsertStatus_OutOfMemory = 2,
+ // LINT.ThenChange(//depot/google3/third_party/upb/upb/map.h)
+} _upb_MapInsertStatus;
+
+UPB_INLINE _upb_MapInsertStatus _upb_Map_Insert(upb_Map* map, const void* key,
+ size_t key_size, void* val,
+ size_t val_size, upb_Arena* a) {
upb_StringView strkey = _upb_map_tokey(key, key_size);
upb_value tabval = {0};
- if (!_upb_map_tovalue(val, val_size, &tabval, a)) return false;
+ if (!_upb_map_tovalue(val, val_size, &tabval, a)) {
+ return _kUpb_MapInsertStatus_OutOfMemory;
+ }
/* TODO(haberman): add overwrite operation to minimize number of lookups. */
- upb_strtable_remove2(&map->table, strkey.data, strkey.size, NULL);
- return upb_strtable_insert(&map->table, strkey.data, strkey.size, tabval, a);
+ bool removed =
+ upb_strtable_remove2(&map->table, strkey.data, strkey.size, NULL);
+ if (!upb_strtable_insert(&map->table, strkey.data, strkey.size, tabval, a)) {
+ return _kUpb_MapInsertStatus_OutOfMemory;
+ }
+ return removed ? _kUpb_MapInsertStatus_Replaced
+ : _kUpb_MapInsertStatus_Inserted;
}
UPB_INLINE bool _upb_Map_Delete(upb_Map* map, const void* key,
@@ -1822,7 +2111,8 @@
if (!*map) {
*map = _upb_Map_New(arena, key_size, val_size);
}
- return _upb_Map_Set(*map, key, key_size, val, val_size, arena);
+ return _upb_Map_Insert(*map, key, key_size, val, val_size, arena) !=
+ _kUpb_MapInsertStatus_OutOfMemory;
}
UPB_INLINE bool _upb_msg_map_delete(upb_Message* msg, size_t ofs,
@@ -1921,261 +2211,83 @@
#endif /* UPB_MSG_INT_H_ */
+/* This file was generated by upbc (the upb compiler) from the input
+ * file:
+ *
+ * google/protobuf/descriptor.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated. */
-/** upb/upb_internal.h ************************************************************/
-#ifndef UPB_INT_H_
-#define UPB_INT_H_
+#ifndef GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H_
+#define GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H_
-struct mem_block;
-typedef struct mem_block mem_block;
-
-struct upb_Arena {
- _upb_ArenaHead head;
- /* Stores cleanup metadata for this arena.
- * - a pointer to the current cleanup counter.
- * - a boolean indicating if there is an unowned initial block. */
- uintptr_t cleanup_metadata;
-
- /* Allocator to allocate arena blocks. We are responsible for freeing these
- * when we are destroyed. */
- upb_alloc* block_alloc;
- uint32_t last_size;
-
- /* When multiple arenas are fused together, each arena points to a parent
- * arena (root points to itself). The root tracks how many live arenas
- * reference it. */
- uint32_t refcount; /* Only used when a->parent == a */
- struct upb_Arena* parent;
-
- /* Linked list of blocks to free/cleanup. */
- mem_block *freelist, *freelist_tail;
-};
-
-// Encodes a float or double that is round-trippable, but as short as possible.
-// These routines are not fully optimal (not guaranteed to be shortest), but are
-// short-ish and match the implementation that has been used in protobuf since
-// the beginning.
-//
-// The given buffer size must be at least kUpb_RoundTripBufferSize.
-enum { kUpb_RoundTripBufferSize = 32 };
-void _upb_EncodeRoundTripDouble(double val, char* buf, size_t size);
-void _upb_EncodeRoundTripFloat(float val, char* buf, size_t size);
-
-#endif /* UPB_INT_H_ */
-
-/* Must be last. */
-
-#define DECODE_NOGROUP (uint32_t) - 1
-
-typedef struct upb_Decoder {
- const char* end; /* Can read up to 16 bytes slop beyond this. */
- const char* limit_ptr; /* = end + UPB_MIN(limit, 0) */
- upb_Message* unknown_msg; /* If non-NULL, add unknown data at buffer flip. */
- const char* unknown; /* Start of unknown data. */
- const upb_ExtensionRegistry*
- extreg; /* For looking up extensions during the parse. */
- int limit; /* Submessage limit relative to end. */
- int depth; /* Tracks recursion depth to bound stack usage. */
- uint32_t end_group; /* field number of END_GROUP tag, else DECODE_NOGROUP */
- uint16_t options;
- bool missing_required;
- char patch[32];
- upb_Arena arena;
- jmp_buf err;
-
-#ifndef NDEBUG
- const char* debug_tagstart;
- const char* debug_valstart;
-#endif
-} upb_Decoder;
-
-/* Error function that will abort decoding with longjmp(). We can't declare this
- * UPB_NORETURN, even though it is appropriate, because if we do then compilers
- * will "helpfully" refuse to tailcall to it
- * (see: https://stackoverflow.com/a/55657013), which will defeat a major goal
- * of our optimizations. That is also why we must declare it in a separate file,
- * otherwise the compiler will see that it calls longjmp() and deduce that it is
- * noreturn. */
-const char* fastdecode_err(upb_Decoder* d, int status);
-
-extern const uint8_t upb_utf8_offsets[];
-
-UPB_INLINE
-bool decode_verifyutf8_inl(const char* ptr, int len) {
- const char* end = ptr + len;
-
- // Check 8 bytes at a time for any non-ASCII char.
- while (end - ptr >= 8) {
- uint64_t data;
- memcpy(&data, ptr, 8);
- if (data & 0x8080808080808080) goto non_ascii;
- ptr += 8;
- }
-
- // Check one byte at a time for non-ASCII.
- while (ptr < end) {
- if (*ptr & 0x80) goto non_ascii;
- ptr++;
- }
-
- return true;
-
-non_ascii:
- return utf8_range2((const unsigned char*)ptr, end - ptr) == 0;
-}
-
-const char* decode_checkrequired(upb_Decoder* d, const char* ptr,
- const upb_Message* msg,
- const upb_MiniTable* l);
-
-/* x86-64 pointers always have the high 16 bits matching. So we can shift
- * left 8 and right 8 without loss of information. */
-UPB_INLINE intptr_t decode_totable(const upb_MiniTable* tablep) {
- return ((intptr_t)tablep << 8) | tablep->table_mask;
-}
-
-UPB_INLINE const upb_MiniTable* decode_totablep(intptr_t table) {
- return (const upb_MiniTable*)(table >> 8);
-}
-
-UPB_INLINE
-const char* decode_isdonefallback_inl(upb_Decoder* d, const char* ptr,
- int overrun, int* status) {
- if (overrun < d->limit) {
- /* Need to copy remaining data into patch buffer. */
- UPB_ASSERT(overrun < 16);
- if (d->unknown_msg) {
- if (!_upb_Message_AddUnknown(d->unknown_msg, d->unknown, ptr - d->unknown,
- &d->arena)) {
- *status = kUpb_DecodeStatus_OutOfMemory;
- return NULL;
- }
- d->unknown = &d->patch[0] + overrun;
- }
- memset(d->patch + 16, 0, 16);
- memcpy(d->patch, d->end, 16);
- ptr = &d->patch[0] + overrun;
- d->end = &d->patch[16];
- d->limit -= 16;
- d->limit_ptr = d->end + d->limit;
- d->options &= ~kUpb_DecodeOption_AliasString;
- UPB_ASSERT(ptr < d->limit_ptr);
- return ptr;
- } else {
- *status = kUpb_DecodeStatus_Malformed;
- return NULL;
- }
-}
-
-const char* decode_isdonefallback(upb_Decoder* d, const char* ptr, int overrun);
-
-UPB_INLINE
-bool decode_isdone(upb_Decoder* d, const char** ptr) {
- int overrun = *ptr - d->end;
- if (UPB_LIKELY(*ptr < d->limit_ptr)) {
- return false;
- } else if (UPB_LIKELY(overrun == d->limit)) {
- return true;
- } else {
- *ptr = decode_isdonefallback(d, *ptr, overrun);
- return false;
- }
-}
-
-#if UPB_FASTTABLE
-UPB_INLINE
-const char* fastdecode_tagdispatch(upb_Decoder* d, const char* ptr,
- upb_Message* msg, intptr_t table,
- uint64_t hasbits, uint64_t tag) {
- const upb_MiniTable* table_p = decode_totablep(table);
- uint8_t mask = table;
- uint64_t data;
- size_t idx = tag & mask;
- UPB_ASSUME((idx & 7) == 0);
- idx >>= 3;
- data = table_p->fasttable[idx].field_data ^ tag;
- UPB_MUSTTAIL return table_p->fasttable[idx].field_parser(d, ptr, msg, table,
- hasbits, data);
-}
-#endif
-
-UPB_INLINE uint32_t fastdecode_loadtag(const char* ptr) {
- uint16_t tag;
- memcpy(&tag, ptr, 2);
- return tag;
-}
-
-UPB_INLINE void decode_checklimit(upb_Decoder* d) {
- UPB_ASSERT(d->limit_ptr == d->end + UPB_MIN(0, d->limit));
-}
-
-UPB_INLINE int decode_pushlimit(upb_Decoder* d, const char* ptr, int size) {
- int limit = size + (int)(ptr - d->end);
- int delta = d->limit - limit;
- decode_checklimit(d);
- d->limit = limit;
- d->limit_ptr = d->end + UPB_MIN(0, limit);
- decode_checklimit(d);
- return delta;
-}
-
-UPB_INLINE void decode_poplimit(upb_Decoder* d, const char* ptr,
- int saved_delta) {
- UPB_ASSERT(ptr - d->end == d->limit);
- decode_checklimit(d);
- d->limit += saved_delta;
- d->limit_ptr = d->end + UPB_MIN(0, d->limit);
- decode_checklimit(d);
-}
-
-
-#endif /* UPB_DECODE_INT_H_ */
-
-/** upb/encode.h ************************************************************/
/*
- * upb_Encode: parsing into a upb_Message using a upb_MiniTable.
+ * upb_decode: parsing into a upb_Message using a upb_MiniTable.
*/
-#ifndef UPB_ENCODE_H_
-#define UPB_ENCODE_H_
+#ifndef UPB_DECODE_H_
+#define UPB_DECODE_H_
-/* Must be last. */
+// Must be last.
#ifdef __cplusplus
extern "C" {
#endif
enum {
- /* If set, the results of serializing will be deterministic across all
- * instances of this binary. There are no guarantees across different
- * binary builds.
+ /* If set, strings will alias the input buffer instead of copying into the
+ * arena. */
+ kUpb_DecodeOption_AliasString = 1,
+
+ /* If set, the parse will return failure if any message is missing any
+ * required fields when the message data ends. The parse will still continue,
+ * and the failure will only be reported at the end.
*
- * If your proto contains maps, the encoder will need to malloc()/free()
- * memory during encode. */
- kUpb_Encode_Deterministic = 1,
-
- /* When set, unknown fields are not printed. */
- kUpb_Encode_SkipUnknown = 2,
-
- /* When set, the encode will fail if any required fields are missing. */
- kUpb_Encode_CheckRequired = 4,
+ * IMPORTANT CAVEATS:
+ *
+ * 1. This can throw a false positive failure if an incomplete message is seen
+ * on the wire but is later completed when the sub-message occurs again.
+ * For this reason, a second pass is required to verify a failure, to be
+ * truly robust.
+ *
+ * 2. This can return a false success if you are decoding into a message that
+ * already has some sub-message fields present. If the sub-message does
+ * not occur in the binary payload, we will never visit it and discover the
+ * incomplete sub-message. For this reason, this check is only useful for
+ * implemting ParseFromString() semantics. For MergeFromString(), a
+ * post-parse validation step will always be necessary. */
+ kUpb_DecodeOption_CheckRequired = 2,
};
-#define UPB_ENCODE_MAXDEPTH(depth) ((depth) << 16)
+#define UPB_DECODE_MAXDEPTH(depth) ((depth) << 16)
-char* upb_Encode(const void* msg, const upb_MiniTable* l, int options,
- upb_Arena* arena, size_t* size);
+typedef enum {
+ kUpb_DecodeStatus_Ok = 0,
+ kUpb_DecodeStatus_Malformed = 1, // Wire format was corrupt
+ kUpb_DecodeStatus_OutOfMemory = 2, // Arena alloc failed
+ kUpb_DecodeStatus_BadUtf8 = 3, // String field had bad UTF-8
+ kUpb_DecodeStatus_MaxDepthExceeded = 4, // Exceeded UPB_DECODE_MAXDEPTH
+ // kUpb_DecodeOption_CheckRequired failed (see above), but the parse otherwise
+ // succeeded.
+ kUpb_DecodeStatus_MissingRequired = 5,
+} upb_DecodeStatus;
+
+upb_DecodeStatus upb_Decode(const char* buf, size_t size, upb_Message* msg,
+ const upb_MiniTable* l,
+ const upb_ExtensionRegistry* extreg, int options,
+ upb_Arena* arena);
#ifdef __cplusplus
} /* extern "C" */
#endif
-#endif /* UPB_ENCODE_H_ */
-/** upb/decode_fast.h ************************************************************/
+#endif /* UPB_DECODE_H_ */
+
// These are the specialized field parser functions for the fast parser.
// Generated tables will refer to these by name.
//
@@ -2214,13 +2326,20 @@
#define UPB_DECODE_FAST_H_
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
struct upb_Decoder;
// The fallback, generic parsing function that can handle any field type.
// This just uses the regular (non-fast) parser to parse a single field.
-const char* fastdecode_generic(struct upb_Decoder* d, const char* ptr,
- upb_Message* msg, intptr_t table,
- uint64_t hasbits, uint64_t data);
+const char* _upb_FastDecoder_DecodeGeneric(struct upb_Decoder* d,
+ const char* ptr, upb_Message* msg,
+ intptr_t table, uint64_t hasbits,
+ uint64_t data);
#define UPB_PARSE_PARAMS \
struct upb_Decoder *d, const char *ptr, upb_Message *msg, intptr_t table, \
@@ -2300,52 +2419,70 @@
#undef UPB_PARSE_PARAMS
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
#endif /* UPB_DECODE_FAST_H_ */
-/** google/protobuf/descriptor.upb.h ************************************************************//* This file was generated by upbc (the upb compiler) from the input
- * file:
- *
- * google/protobuf/descriptor.proto
- *
- * Do not edit -- your changes will be discarded when the file is
- * regenerated. */
+/*
+ * upb_Encode: parsing from a upb_Message using a upb_MiniTable.
+ */
-#ifndef GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H_
-#define GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H_
+#ifndef UPB_ENCODE_H_
+#define UPB_ENCODE_H_
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+ /* If set, the results of serializing will be deterministic across all
+ * instances of this binary. There are no guarantees across different
+ * binary builds.
+ *
+ * If your proto contains maps, the encoder will need to malloc()/free()
+ * memory during encode. */
+ kUpb_EncodeOption_Deterministic = 1,
+
+ /* When set, unknown fields are not printed. */
+ kUpb_EncodeOption_SkipUnknown = 2,
+
+ /* When set, the encode will fail if any required fields are missing. */
+ kUpb_EncodeOption_CheckRequired = 4,
+};
+
+#define UPB_ENCODE_MAXDEPTH(depth) ((depth) << 16)
+
+typedef enum {
+ kUpb_EncodeStatus_Ok = 0,
+ kUpb_EncodeStatus_OutOfMemory = 1, // Arena alloc failed
+ kUpb_EncodeStatus_MaxDepthExceeded = 2, // Exceeded UPB_ENCODE_MAXDEPTH
+
+ // kUpb_EncodeOption_CheckRequired failed but the parse otherwise succeeded.
+ kUpb_EncodeStatus_MissingRequired = 3,
+} upb_EncodeStatus;
+
+upb_EncodeStatus upb_Encode(const void* msg, const upb_MiniTable* l,
+ int options, upb_Arena* arena, char** buf,
+ size_t* size);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_ENCODE_H_ */
+
#ifdef __cplusplus
extern "C" {
#endif
-struct google_protobuf_FileDescriptorSet;
-struct google_protobuf_FileDescriptorProto;
-struct google_protobuf_DescriptorProto;
-struct google_protobuf_DescriptorProto_ExtensionRange;
-struct google_protobuf_DescriptorProto_ReservedRange;
-struct google_protobuf_ExtensionRangeOptions;
-struct google_protobuf_FieldDescriptorProto;
-struct google_protobuf_OneofDescriptorProto;
-struct google_protobuf_EnumDescriptorProto;
-struct google_protobuf_EnumDescriptorProto_EnumReservedRange;
-struct google_protobuf_EnumValueDescriptorProto;
-struct google_protobuf_ServiceDescriptorProto;
-struct google_protobuf_MethodDescriptorProto;
-struct google_protobuf_FileOptions;
-struct google_protobuf_MessageOptions;
-struct google_protobuf_FieldOptions;
-struct google_protobuf_OneofOptions;
-struct google_protobuf_EnumOptions;
-struct google_protobuf_EnumValueOptions;
-struct google_protobuf_ServiceOptions;
-struct google_protobuf_MethodOptions;
-struct google_protobuf_UninterpretedOption;
-struct google_protobuf_UninterpretedOption_NamePart;
-struct google_protobuf_SourceCodeInfo;
-struct google_protobuf_SourceCodeInfo_Location;
-struct google_protobuf_GeneratedCodeInfo;
-struct google_protobuf_GeneratedCodeInfo_Annotation;
typedef struct google_protobuf_FileDescriptorSet google_protobuf_FileDescriptorSet;
typedef struct google_protobuf_FileDescriptorProto google_protobuf_FileDescriptorProto;
typedef struct google_protobuf_DescriptorProto google_protobuf_DescriptorProto;
@@ -2373,33 +2510,33 @@
typedef struct google_protobuf_SourceCodeInfo_Location google_protobuf_SourceCodeInfo_Location;
typedef struct google_protobuf_GeneratedCodeInfo google_protobuf_GeneratedCodeInfo;
typedef struct google_protobuf_GeneratedCodeInfo_Annotation google_protobuf_GeneratedCodeInfo_Annotation;
-extern const upb_MiniTable google_protobuf_FileDescriptorSet_msginit;
-extern const upb_MiniTable google_protobuf_FileDescriptorProto_msginit;
-extern const upb_MiniTable google_protobuf_DescriptorProto_msginit;
-extern const upb_MiniTable google_protobuf_DescriptorProto_ExtensionRange_msginit;
-extern const upb_MiniTable google_protobuf_DescriptorProto_ReservedRange_msginit;
-extern const upb_MiniTable google_protobuf_ExtensionRangeOptions_msginit;
-extern const upb_MiniTable google_protobuf_FieldDescriptorProto_msginit;
-extern const upb_MiniTable google_protobuf_OneofDescriptorProto_msginit;
-extern const upb_MiniTable google_protobuf_EnumDescriptorProto_msginit;
-extern const upb_MiniTable google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit;
-extern const upb_MiniTable google_protobuf_EnumValueDescriptorProto_msginit;
-extern const upb_MiniTable google_protobuf_ServiceDescriptorProto_msginit;
-extern const upb_MiniTable google_protobuf_MethodDescriptorProto_msginit;
-extern const upb_MiniTable google_protobuf_FileOptions_msginit;
-extern const upb_MiniTable google_protobuf_MessageOptions_msginit;
-extern const upb_MiniTable google_protobuf_FieldOptions_msginit;
-extern const upb_MiniTable google_protobuf_OneofOptions_msginit;
-extern const upb_MiniTable google_protobuf_EnumOptions_msginit;
-extern const upb_MiniTable google_protobuf_EnumValueOptions_msginit;
-extern const upb_MiniTable google_protobuf_ServiceOptions_msginit;
-extern const upb_MiniTable google_protobuf_MethodOptions_msginit;
-extern const upb_MiniTable google_protobuf_UninterpretedOption_msginit;
-extern const upb_MiniTable google_protobuf_UninterpretedOption_NamePart_msginit;
-extern const upb_MiniTable google_protobuf_SourceCodeInfo_msginit;
-extern const upb_MiniTable google_protobuf_SourceCodeInfo_Location_msginit;
-extern const upb_MiniTable google_protobuf_GeneratedCodeInfo_msginit;
-extern const upb_MiniTable google_protobuf_GeneratedCodeInfo_Annotation_msginit;
+extern const upb_MiniTable google_protobuf_FileDescriptorSet_msg_init;
+extern const upb_MiniTable google_protobuf_FileDescriptorProto_msg_init;
+extern const upb_MiniTable google_protobuf_DescriptorProto_msg_init;
+extern const upb_MiniTable google_protobuf_DescriptorProto_ExtensionRange_msg_init;
+extern const upb_MiniTable google_protobuf_DescriptorProto_ReservedRange_msg_init;
+extern const upb_MiniTable google_protobuf_ExtensionRangeOptions_msg_init;
+extern const upb_MiniTable google_protobuf_FieldDescriptorProto_msg_init;
+extern const upb_MiniTable google_protobuf_OneofDescriptorProto_msg_init;
+extern const upb_MiniTable google_protobuf_EnumDescriptorProto_msg_init;
+extern const upb_MiniTable google_protobuf_EnumDescriptorProto_EnumReservedRange_msg_init;
+extern const upb_MiniTable google_protobuf_EnumValueDescriptorProto_msg_init;
+extern const upb_MiniTable google_protobuf_ServiceDescriptorProto_msg_init;
+extern const upb_MiniTable google_protobuf_MethodDescriptorProto_msg_init;
+extern const upb_MiniTable google_protobuf_FileOptions_msg_init;
+extern const upb_MiniTable google_protobuf_MessageOptions_msg_init;
+extern const upb_MiniTable google_protobuf_FieldOptions_msg_init;
+extern const upb_MiniTable google_protobuf_OneofOptions_msg_init;
+extern const upb_MiniTable google_protobuf_EnumOptions_msg_init;
+extern const upb_MiniTable google_protobuf_EnumValueOptions_msg_init;
+extern const upb_MiniTable google_protobuf_ServiceOptions_msg_init;
+extern const upb_MiniTable google_protobuf_MethodOptions_msg_init;
+extern const upb_MiniTable google_protobuf_UninterpretedOption_msg_init;
+extern const upb_MiniTable google_protobuf_UninterpretedOption_NamePart_msg_init;
+extern const upb_MiniTable google_protobuf_SourceCodeInfo_msg_init;
+extern const upb_MiniTable google_protobuf_SourceCodeInfo_Location_msg_init;
+extern const upb_MiniTable google_protobuf_GeneratedCodeInfo_msg_init;
+extern const upb_MiniTable google_protobuf_GeneratedCodeInfo_Annotation_msg_init;
typedef enum {
google_protobuf_FieldDescriptorProto_LABEL_OPTIONAL = 1,
@@ -2447,28 +2584,35 @@
} google_protobuf_FileOptions_OptimizeMode;
typedef enum {
+ google_protobuf_GeneratedCodeInfo_Annotation_NONE = 0,
+ google_protobuf_GeneratedCodeInfo_Annotation_SET = 1,
+ google_protobuf_GeneratedCodeInfo_Annotation_ALIAS = 2
+} google_protobuf_GeneratedCodeInfo_Annotation_Semantic;
+
+typedef enum {
google_protobuf_MethodOptions_IDEMPOTENCY_UNKNOWN = 0,
google_protobuf_MethodOptions_NO_SIDE_EFFECTS = 1,
google_protobuf_MethodOptions_IDEMPOTENT = 2
} google_protobuf_MethodOptions_IdempotencyLevel;
-extern const upb_MiniTable_Enum google_protobuf_FieldDescriptorProto_Label_enuminit;
-extern const upb_MiniTable_Enum google_protobuf_FieldDescriptorProto_Type_enuminit;
-extern const upb_MiniTable_Enum google_protobuf_FieldOptions_CType_enuminit;
-extern const upb_MiniTable_Enum google_protobuf_FieldOptions_JSType_enuminit;
-extern const upb_MiniTable_Enum google_protobuf_FileOptions_OptimizeMode_enuminit;
-extern const upb_MiniTable_Enum google_protobuf_MethodOptions_IdempotencyLevel_enuminit;
+extern const upb_MiniTable_Enum google_protobuf_FieldDescriptorProto_Label_enum_init;
+extern const upb_MiniTable_Enum google_protobuf_FieldDescriptorProto_Type_enum_init;
+extern const upb_MiniTable_Enum google_protobuf_FieldOptions_CType_enum_init;
+extern const upb_MiniTable_Enum google_protobuf_FieldOptions_JSType_enum_init;
+extern const upb_MiniTable_Enum google_protobuf_FileOptions_OptimizeMode_enum_init;
+extern const upb_MiniTable_Enum google_protobuf_GeneratedCodeInfo_Annotation_Semantic_enum_init;
+extern const upb_MiniTable_Enum google_protobuf_MethodOptions_IdempotencyLevel_enum_init;
/* google.protobuf.FileDescriptorSet */
UPB_INLINE google_protobuf_FileDescriptorSet* google_protobuf_FileDescriptorSet_new(upb_Arena* arena) {
- return (google_protobuf_FileDescriptorSet*)_upb_Message_New(&google_protobuf_FileDescriptorSet_msginit, arena);
+ return (google_protobuf_FileDescriptorSet*)_upb_Message_New(&google_protobuf_FileDescriptorSet_msg_init, arena);
}
UPB_INLINE google_protobuf_FileDescriptorSet* google_protobuf_FileDescriptorSet_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_FileDescriptorSet* ret = google_protobuf_FileDescriptorSet_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_FileDescriptorSet_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_FileDescriptorSet_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -2478,22 +2622,29 @@
int options, upb_Arena* arena) {
google_protobuf_FileDescriptorSet* ret = google_protobuf_FileDescriptorSet_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_FileDescriptorSet_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_FileDescriptorSet_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_FileDescriptorSet_serialize(const google_protobuf_FileDescriptorSet* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_FileDescriptorSet_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_FileDescriptorSet_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_FileDescriptorSet_serialize_ex(const google_protobuf_FileDescriptorSet* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_FileDescriptorSet_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_FileDescriptorSet_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_FileDescriptorSet_has_file(const google_protobuf_FileDescriptorSet* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0));
}
+UPB_INLINE void google_protobuf_FileDescriptorSet_clear_file(const google_protobuf_FileDescriptorSet* msg) {
+ _upb_array_detach(msg, UPB_SIZE(0, 0));
+}
UPB_INLINE const google_protobuf_FileDescriptorProto* const* google_protobuf_FileDescriptorSet_file(const google_protobuf_FileDescriptorSet* msg, size_t* len) {
return (const google_protobuf_FileDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len);
}
@@ -2505,7 +2656,7 @@
return (google_protobuf_FileDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(0, 0), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_FileDescriptorProto* google_protobuf_FileDescriptorSet_add_file(google_protobuf_FileDescriptorSet* msg, upb_Arena* arena) {
- struct google_protobuf_FileDescriptorProto* sub = (struct google_protobuf_FileDescriptorProto*)_upb_Message_New(&google_protobuf_FileDescriptorProto_msginit, arena);
+ struct google_protobuf_FileDescriptorProto* sub = (struct google_protobuf_FileDescriptorProto*)_upb_Message_New(&google_protobuf_FileDescriptorProto_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(0, 0), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -2514,12 +2665,12 @@
/* google.protobuf.FileDescriptorProto */
UPB_INLINE google_protobuf_FileDescriptorProto* google_protobuf_FileDescriptorProto_new(upb_Arena* arena) {
- return (google_protobuf_FileDescriptorProto*)_upb_Message_New(&google_protobuf_FileDescriptorProto_msginit, arena);
+ return (google_protobuf_FileDescriptorProto*)_upb_Message_New(&google_protobuf_FileDescriptorProto_msg_init, arena);
}
UPB_INLINE google_protobuf_FileDescriptorProto* google_protobuf_FileDescriptorProto_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_FileDescriptorProto* ret = google_protobuf_FileDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_FileDescriptorProto_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_FileDescriptorProto_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -2529,81 +2680,136 @@
int options, upb_Arena* arena) {
google_protobuf_FileDescriptorProto* ret = google_protobuf_FileDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_FileDescriptorProto_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_FileDescriptorProto_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_FileDescriptorProto_serialize(const google_protobuf_FileDescriptorProto* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_FileDescriptorProto_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_FileDescriptorProto_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_FileDescriptorProto_serialize_ex(const google_protobuf_FileDescriptorProto* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_FileDescriptorProto_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_FileDescriptorProto_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_has_name(const google_protobuf_FileDescriptorProto* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_name(const google_protobuf_FileDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_FileDescriptorProto_name(const google_protobuf_FileDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView);
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_has_package(const google_protobuf_FileDescriptorProto* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_package(const google_protobuf_FileDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE upb_StringView google_protobuf_FileDescriptorProto_package(const google_protobuf_FileDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_StringView);
}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_dependency(const google_protobuf_FileDescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(20, 40));
+}
UPB_INLINE upb_StringView const* google_protobuf_FileDescriptorProto_dependency(const google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(36, 72), len);
+ return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(20, 40), len);
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_has_message_type(const google_protobuf_FileDescriptorProto* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(40, 80));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(24, 48));
+}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_message_type(const google_protobuf_FileDescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(24, 48));
}
UPB_INLINE const google_protobuf_DescriptorProto* const* google_protobuf_FileDescriptorProto_message_type(const google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (const google_protobuf_DescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(40, 80), len);
+ return (const google_protobuf_DescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len);
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_has_enum_type(const google_protobuf_FileDescriptorProto* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(44, 88));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(28, 56));
+}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_enum_type(const google_protobuf_FileDescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(28, 56));
}
UPB_INLINE const google_protobuf_EnumDescriptorProto* const* google_protobuf_FileDescriptorProto_enum_type(const google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (const google_protobuf_EnumDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(44, 88), len);
+ return (const google_protobuf_EnumDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(28, 56), len);
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_has_service(const google_protobuf_FileDescriptorProto* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(48, 96));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(32, 64));
+}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_service(const google_protobuf_FileDescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(32, 64));
}
UPB_INLINE const google_protobuf_ServiceDescriptorProto* const* google_protobuf_FileDescriptorProto_service(const google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (const google_protobuf_ServiceDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(48, 96), len);
+ return (const google_protobuf_ServiceDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(32, 64), len);
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_has_extension(const google_protobuf_FileDescriptorProto* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(52, 104));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(36, 72));
+}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_extension(const google_protobuf_FileDescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(36, 72));
}
UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_FileDescriptorProto_extension(const google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(52, 104), len);
+ return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(36, 72), len);
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_has_options(const google_protobuf_FileDescriptorProto* msg) {
return _upb_hasbit(msg, 3);
}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_options(const google_protobuf_FileDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(40, 80), const upb_Message*) = NULL;
+ _upb_clearhas(msg, 3);
+}
UPB_INLINE const google_protobuf_FileOptions* google_protobuf_FileDescriptorProto_options(const google_protobuf_FileDescriptorProto* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(28, 56), const google_protobuf_FileOptions*);
+ return *UPB_PTR_AT(msg, UPB_SIZE(40, 80), const google_protobuf_FileOptions*);
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_has_source_code_info(const google_protobuf_FileDescriptorProto* msg) {
return _upb_hasbit(msg, 4);
}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_source_code_info(const google_protobuf_FileDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(44, 88), const upb_Message*) = NULL;
+ _upb_clearhas(msg, 4);
+}
UPB_INLINE const google_protobuf_SourceCodeInfo* google_protobuf_FileDescriptorProto_source_code_info(const google_protobuf_FileDescriptorProto* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(32, 64), const google_protobuf_SourceCodeInfo*);
+ return *UPB_PTR_AT(msg, UPB_SIZE(44, 88), const google_protobuf_SourceCodeInfo*);
+}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_public_dependency(const google_protobuf_FileDescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(48, 96));
}
UPB_INLINE int32_t const* google_protobuf_FileDescriptorProto_public_dependency(const google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(56, 112), len);
+ return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(48, 96), len);
+}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_weak_dependency(const google_protobuf_FileDescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(52, 104));
}
UPB_INLINE int32_t const* google_protobuf_FileDescriptorProto_weak_dependency(const google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(60, 120), len);
+ return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(52, 104), len);
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_has_syntax(const google_protobuf_FileDescriptorProto* msg) {
return _upb_hasbit(msg, 5);
}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_syntax(const google_protobuf_FileDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(56, 112), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 5);
+}
UPB_INLINE upb_StringView google_protobuf_FileDescriptorProto_syntax(const google_protobuf_FileDescriptorProto* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_StringView);
+ return *UPB_PTR_AT(msg, UPB_SIZE(56, 112), upb_StringView);
+}
+UPB_INLINE bool google_protobuf_FileDescriptorProto_has_edition(const google_protobuf_FileDescriptorProto* msg) {
+ return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void google_protobuf_FileDescriptorProto_clear_edition(const google_protobuf_FileDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(64, 128), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 6);
+}
+UPB_INLINE upb_StringView google_protobuf_FileDescriptorProto_edition(const google_protobuf_FileDescriptorProto* msg) {
+ return *UPB_PTR_AT(msg, UPB_SIZE(64, 128), upb_StringView);
}
UPB_INLINE void google_protobuf_FileDescriptorProto_set_name(google_protobuf_FileDescriptorProto *msg, upb_StringView value) {
@@ -2615,70 +2821,70 @@
*UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_StringView) = value;
}
UPB_INLINE upb_StringView* google_protobuf_FileDescriptorProto_mutable_dependency(google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(36, 72), len);
+ return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(20, 40), len);
}
UPB_INLINE upb_StringView* google_protobuf_FileDescriptorProto_resize_dependency(google_protobuf_FileDescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(36, 72), len, UPB_SIZE(3, 4), arena);
+ return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(20, 40), len, UPB_SIZE(3, 4), arena);
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_add_dependency(google_protobuf_FileDescriptorProto* msg, upb_StringView val, upb_Arena* arena) {
- return _upb_Array_Append_accessor2(msg, UPB_SIZE(36, 72), UPB_SIZE(3, 4), &val, arena);
+ return _upb_Array_Append_accessor2(msg, UPB_SIZE(20, 40), UPB_SIZE(3, 4), &val, arena);
}
UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_FileDescriptorProto_mutable_message_type(google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (google_protobuf_DescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(40, 80), len);
+ return (google_protobuf_DescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 48), len);
}
UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_FileDescriptorProto_resize_message_type(google_protobuf_FileDescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_DescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(40, 80), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_DescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(24, 48), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_DescriptorProto* google_protobuf_FileDescriptorProto_add_message_type(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_DescriptorProto* sub = (struct google_protobuf_DescriptorProto*)_upb_Message_New(&google_protobuf_DescriptorProto_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(40, 80), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_DescriptorProto* sub = (struct google_protobuf_DescriptorProto*)_upb_Message_New(&google_protobuf_DescriptorProto_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(24, 48), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_FileDescriptorProto_mutable_enum_type(google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (google_protobuf_EnumDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(44, 88), len);
+ return (google_protobuf_EnumDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 56), len);
}
UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_FileDescriptorProto_resize_enum_type(google_protobuf_FileDescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_EnumDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(44, 88), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_EnumDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(28, 56), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_EnumDescriptorProto* google_protobuf_FileDescriptorProto_add_enum_type(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_EnumDescriptorProto* sub = (struct google_protobuf_EnumDescriptorProto*)_upb_Message_New(&google_protobuf_EnumDescriptorProto_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(44, 88), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_EnumDescriptorProto* sub = (struct google_protobuf_EnumDescriptorProto*)_upb_Message_New(&google_protobuf_EnumDescriptorProto_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 56), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE google_protobuf_ServiceDescriptorProto** google_protobuf_FileDescriptorProto_mutable_service(google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (google_protobuf_ServiceDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(48, 96), len);
+ return (google_protobuf_ServiceDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(32, 64), len);
}
UPB_INLINE google_protobuf_ServiceDescriptorProto** google_protobuf_FileDescriptorProto_resize_service(google_protobuf_FileDescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_ServiceDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(48, 96), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_ServiceDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(32, 64), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_ServiceDescriptorProto* google_protobuf_FileDescriptorProto_add_service(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_ServiceDescriptorProto* sub = (struct google_protobuf_ServiceDescriptorProto*)_upb_Message_New(&google_protobuf_ServiceDescriptorProto_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(48, 96), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_ServiceDescriptorProto* sub = (struct google_protobuf_ServiceDescriptorProto*)_upb_Message_New(&google_protobuf_ServiceDescriptorProto_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 64), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_FileDescriptorProto_mutable_extension(google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (google_protobuf_FieldDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 104), len);
+ return (google_protobuf_FieldDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(36, 72), len);
}
UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_FileDescriptorProto_resize_extension(google_protobuf_FileDescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_FieldDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(52, 104), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_FieldDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(36, 72), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_FileDescriptorProto_add_extension(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)_upb_Message_New(&google_protobuf_FieldDescriptorProto_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(52, 104), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)_upb_Message_New(&google_protobuf_FieldDescriptorProto_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(36, 72), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE void google_protobuf_FileDescriptorProto_set_options(google_protobuf_FileDescriptorProto *msg, google_protobuf_FileOptions* value) {
_upb_sethas(msg, 3);
- *UPB_PTR_AT(msg, UPB_SIZE(28, 56), google_protobuf_FileOptions*) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(40, 80), google_protobuf_FileOptions*) = value;
}
UPB_INLINE struct google_protobuf_FileOptions* google_protobuf_FileDescriptorProto_mutable_options(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
struct google_protobuf_FileOptions* sub = (struct google_protobuf_FileOptions*)google_protobuf_FileDescriptorProto_options(msg);
if (sub == NULL) {
- sub = (struct google_protobuf_FileOptions*)_upb_Message_New(&google_protobuf_FileOptions_msginit, arena);
+ sub = (struct google_protobuf_FileOptions*)_upb_Message_New(&google_protobuf_FileOptions_msg_init, arena);
if (!sub) return NULL;
google_protobuf_FileDescriptorProto_set_options(msg, sub);
}
@@ -2686,49 +2892,53 @@
}
UPB_INLINE void google_protobuf_FileDescriptorProto_set_source_code_info(google_protobuf_FileDescriptorProto *msg, google_protobuf_SourceCodeInfo* value) {
_upb_sethas(msg, 4);
- *UPB_PTR_AT(msg, UPB_SIZE(32, 64), google_protobuf_SourceCodeInfo*) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(44, 88), google_protobuf_SourceCodeInfo*) = value;
}
UPB_INLINE struct google_protobuf_SourceCodeInfo* google_protobuf_FileDescriptorProto_mutable_source_code_info(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
struct google_protobuf_SourceCodeInfo* sub = (struct google_protobuf_SourceCodeInfo*)google_protobuf_FileDescriptorProto_source_code_info(msg);
if (sub == NULL) {
- sub = (struct google_protobuf_SourceCodeInfo*)_upb_Message_New(&google_protobuf_SourceCodeInfo_msginit, arena);
+ sub = (struct google_protobuf_SourceCodeInfo*)_upb_Message_New(&google_protobuf_SourceCodeInfo_msg_init, arena);
if (!sub) return NULL;
google_protobuf_FileDescriptorProto_set_source_code_info(msg, sub);
}
return sub;
}
UPB_INLINE int32_t* google_protobuf_FileDescriptorProto_mutable_public_dependency(google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 112), len);
+ return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(48, 96), len);
}
UPB_INLINE int32_t* google_protobuf_FileDescriptorProto_resize_public_dependency(google_protobuf_FileDescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(56, 112), len, 2, arena);
+ return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(48, 96), len, 2, arena);
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_add_public_dependency(google_protobuf_FileDescriptorProto* msg, int32_t val, upb_Arena* arena) {
- return _upb_Array_Append_accessor2(msg, UPB_SIZE(56, 112), 2, &val, arena);
+ return _upb_Array_Append_accessor2(msg, UPB_SIZE(48, 96), 2, &val, arena);
}
UPB_INLINE int32_t* google_protobuf_FileDescriptorProto_mutable_weak_dependency(google_protobuf_FileDescriptorProto* msg, size_t* len) {
- return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(60, 120), len);
+ return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 104), len);
}
UPB_INLINE int32_t* google_protobuf_FileDescriptorProto_resize_weak_dependency(google_protobuf_FileDescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(60, 120), len, 2, arena);
+ return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(52, 104), len, 2, arena);
}
UPB_INLINE bool google_protobuf_FileDescriptorProto_add_weak_dependency(google_protobuf_FileDescriptorProto* msg, int32_t val, upb_Arena* arena) {
- return _upb_Array_Append_accessor2(msg, UPB_SIZE(60, 120), 2, &val, arena);
+ return _upb_Array_Append_accessor2(msg, UPB_SIZE(52, 104), 2, &val, arena);
}
UPB_INLINE void google_protobuf_FileDescriptorProto_set_syntax(google_protobuf_FileDescriptorProto *msg, upb_StringView value) {
_upb_sethas(msg, 5);
- *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_StringView) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(56, 112), upb_StringView) = value;
+}
+UPB_INLINE void google_protobuf_FileDescriptorProto_set_edition(google_protobuf_FileDescriptorProto *msg, upb_StringView value) {
+ _upb_sethas(msg, 6);
+ *UPB_PTR_AT(msg, UPB_SIZE(64, 128), upb_StringView) = value;
}
/* google.protobuf.DescriptorProto */
UPB_INLINE google_protobuf_DescriptorProto* google_protobuf_DescriptorProto_new(upb_Arena* arena) {
- return (google_protobuf_DescriptorProto*)_upb_Message_New(&google_protobuf_DescriptorProto_msginit, arena);
+ return (google_protobuf_DescriptorProto*)_upb_Message_New(&google_protobuf_DescriptorProto_msg_init, arena);
}
UPB_INLINE google_protobuf_DescriptorProto* google_protobuf_DescriptorProto_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_DescriptorProto* ret = google_protobuf_DescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -2738,73 +2948,109 @@
int options, upb_Arena* arena) {
google_protobuf_DescriptorProto* ret = google_protobuf_DescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_DescriptorProto_serialize(const google_protobuf_DescriptorProto* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_DescriptorProto_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_DescriptorProto_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_DescriptorProto_serialize_ex(const google_protobuf_DescriptorProto* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_DescriptorProto_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_DescriptorProto_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_DescriptorProto_has_name(const google_protobuf_DescriptorProto* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_DescriptorProto_clear_name(const google_protobuf_DescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_DescriptorProto_name(const google_protobuf_DescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView);
}
UPB_INLINE bool google_protobuf_DescriptorProto_has_field(const google_protobuf_DescriptorProto* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(16, 32));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(12, 24));
+}
+UPB_INLINE void google_protobuf_DescriptorProto_clear_field(const google_protobuf_DescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(12, 24));
}
UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_DescriptorProto_field(const google_protobuf_DescriptorProto* msg, size_t* len) {
- return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(16, 32), len);
+ return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(12, 24), len);
}
UPB_INLINE bool google_protobuf_DescriptorProto_has_nested_type(const google_protobuf_DescriptorProto* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(20, 40));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(16, 32));
+}
+UPB_INLINE void google_protobuf_DescriptorProto_clear_nested_type(const google_protobuf_DescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(16, 32));
}
UPB_INLINE const google_protobuf_DescriptorProto* const* google_protobuf_DescriptorProto_nested_type(const google_protobuf_DescriptorProto* msg, size_t* len) {
- return (const google_protobuf_DescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(20, 40), len);
+ return (const google_protobuf_DescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(16, 32), len);
}
UPB_INLINE bool google_protobuf_DescriptorProto_has_enum_type(const google_protobuf_DescriptorProto* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(24, 48));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(20, 40));
+}
+UPB_INLINE void google_protobuf_DescriptorProto_clear_enum_type(const google_protobuf_DescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(20, 40));
}
UPB_INLINE const google_protobuf_EnumDescriptorProto* const* google_protobuf_DescriptorProto_enum_type(const google_protobuf_DescriptorProto* msg, size_t* len) {
- return (const google_protobuf_EnumDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len);
+ return (const google_protobuf_EnumDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(20, 40), len);
}
UPB_INLINE bool google_protobuf_DescriptorProto_has_extension_range(const google_protobuf_DescriptorProto* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(28, 56));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(24, 48));
+}
+UPB_INLINE void google_protobuf_DescriptorProto_clear_extension_range(const google_protobuf_DescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(24, 48));
}
UPB_INLINE const google_protobuf_DescriptorProto_ExtensionRange* const* google_protobuf_DescriptorProto_extension_range(const google_protobuf_DescriptorProto* msg, size_t* len) {
- return (const google_protobuf_DescriptorProto_ExtensionRange* const*)_upb_array_accessor(msg, UPB_SIZE(28, 56), len);
+ return (const google_protobuf_DescriptorProto_ExtensionRange* const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len);
}
UPB_INLINE bool google_protobuf_DescriptorProto_has_extension(const google_protobuf_DescriptorProto* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(32, 64));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(28, 56));
+}
+UPB_INLINE void google_protobuf_DescriptorProto_clear_extension(const google_protobuf_DescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(28, 56));
}
UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_DescriptorProto_extension(const google_protobuf_DescriptorProto* msg, size_t* len) {
- return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(32, 64), len);
+ return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(28, 56), len);
}
UPB_INLINE bool google_protobuf_DescriptorProto_has_options(const google_protobuf_DescriptorProto* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_DescriptorProto_clear_options(const google_protobuf_DescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(32, 64), const upb_Message*) = NULL;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE const google_protobuf_MessageOptions* google_protobuf_DescriptorProto_options(const google_protobuf_DescriptorProto* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_MessageOptions*);
+ return *UPB_PTR_AT(msg, UPB_SIZE(32, 64), const google_protobuf_MessageOptions*);
}
UPB_INLINE bool google_protobuf_DescriptorProto_has_oneof_decl(const google_protobuf_DescriptorProto* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(36, 72));
}
+UPB_INLINE void google_protobuf_DescriptorProto_clear_oneof_decl(const google_protobuf_DescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(36, 72));
+}
UPB_INLINE const google_protobuf_OneofDescriptorProto* const* google_protobuf_DescriptorProto_oneof_decl(const google_protobuf_DescriptorProto* msg, size_t* len) {
return (const google_protobuf_OneofDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(36, 72), len);
}
UPB_INLINE bool google_protobuf_DescriptorProto_has_reserved_range(const google_protobuf_DescriptorProto* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(40, 80));
}
+UPB_INLINE void google_protobuf_DescriptorProto_clear_reserved_range(const google_protobuf_DescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(40, 80));
+}
UPB_INLINE const google_protobuf_DescriptorProto_ReservedRange* const* google_protobuf_DescriptorProto_reserved_range(const google_protobuf_DescriptorProto* msg, size_t* len) {
return (const google_protobuf_DescriptorProto_ReservedRange* const*)_upb_array_accessor(msg, UPB_SIZE(40, 80), len);
}
+UPB_INLINE void google_protobuf_DescriptorProto_clear_reserved_name(const google_protobuf_DescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(44, 88));
+}
UPB_INLINE upb_StringView const* google_protobuf_DescriptorProto_reserved_name(const google_protobuf_DescriptorProto* msg, size_t* len) {
return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(44, 88), len);
}
@@ -2814,73 +3060,73 @@
*UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = value;
}
UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProto_mutable_field(google_protobuf_DescriptorProto* msg, size_t* len) {
- return (google_protobuf_FieldDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(16, 32), len);
+ return (google_protobuf_FieldDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(12, 24), len);
}
UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProto_resize_field(google_protobuf_DescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_FieldDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(16, 32), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_FieldDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(12, 24), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_DescriptorProto_add_field(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)_upb_Message_New(&google_protobuf_FieldDescriptorProto_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(16, 32), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)_upb_Message_New(&google_protobuf_FieldDescriptorProto_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(12, 24), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_DescriptorProto_mutable_nested_type(google_protobuf_DescriptorProto* msg, size_t* len) {
- return (google_protobuf_DescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(20, 40), len);
+ return (google_protobuf_DescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(16, 32), len);
}
UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_DescriptorProto_resize_nested_type(google_protobuf_DescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_DescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(20, 40), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_DescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(16, 32), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_DescriptorProto* google_protobuf_DescriptorProto_add_nested_type(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_DescriptorProto* sub = (struct google_protobuf_DescriptorProto*)_upb_Message_New(&google_protobuf_DescriptorProto_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(20, 40), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_DescriptorProto* sub = (struct google_protobuf_DescriptorProto*)_upb_Message_New(&google_protobuf_DescriptorProto_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(16, 32), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_DescriptorProto_mutable_enum_type(google_protobuf_DescriptorProto* msg, size_t* len) {
- return (google_protobuf_EnumDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 48), len);
+ return (google_protobuf_EnumDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(20, 40), len);
}
UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_DescriptorProto_resize_enum_type(google_protobuf_DescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_EnumDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(24, 48), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_EnumDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(20, 40), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_EnumDescriptorProto* google_protobuf_DescriptorProto_add_enum_type(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_EnumDescriptorProto* sub = (struct google_protobuf_EnumDescriptorProto*)_upb_Message_New(&google_protobuf_EnumDescriptorProto_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(24, 48), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_EnumDescriptorProto* sub = (struct google_protobuf_EnumDescriptorProto*)_upb_Message_New(&google_protobuf_EnumDescriptorProto_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(20, 40), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE google_protobuf_DescriptorProto_ExtensionRange** google_protobuf_DescriptorProto_mutable_extension_range(google_protobuf_DescriptorProto* msg, size_t* len) {
- return (google_protobuf_DescriptorProto_ExtensionRange**)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 56), len);
+ return (google_protobuf_DescriptorProto_ExtensionRange**)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 48), len);
}
UPB_INLINE google_protobuf_DescriptorProto_ExtensionRange** google_protobuf_DescriptorProto_resize_extension_range(google_protobuf_DescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_DescriptorProto_ExtensionRange**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(28, 56), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_DescriptorProto_ExtensionRange**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(24, 48), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_DescriptorProto_ExtensionRange* google_protobuf_DescriptorProto_add_extension_range(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_DescriptorProto_ExtensionRange* sub = (struct google_protobuf_DescriptorProto_ExtensionRange*)_upb_Message_New(&google_protobuf_DescriptorProto_ExtensionRange_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 56), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_DescriptorProto_ExtensionRange* sub = (struct google_protobuf_DescriptorProto_ExtensionRange*)_upb_Message_New(&google_protobuf_DescriptorProto_ExtensionRange_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(24, 48), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProto_mutable_extension(google_protobuf_DescriptorProto* msg, size_t* len) {
- return (google_protobuf_FieldDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(32, 64), len);
+ return (google_protobuf_FieldDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 56), len);
}
UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProto_resize_extension(google_protobuf_DescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_FieldDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(32, 64), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_FieldDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(28, 56), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_DescriptorProto_add_extension(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)_upb_Message_New(&google_protobuf_FieldDescriptorProto_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 64), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)_upb_Message_New(&google_protobuf_FieldDescriptorProto_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 56), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE void google_protobuf_DescriptorProto_set_options(google_protobuf_DescriptorProto *msg, google_protobuf_MessageOptions* value) {
_upb_sethas(msg, 2);
- *UPB_PTR_AT(msg, UPB_SIZE(12, 24), google_protobuf_MessageOptions*) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(32, 64), google_protobuf_MessageOptions*) = value;
}
UPB_INLINE struct google_protobuf_MessageOptions* google_protobuf_DescriptorProto_mutable_options(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
struct google_protobuf_MessageOptions* sub = (struct google_protobuf_MessageOptions*)google_protobuf_DescriptorProto_options(msg);
if (sub == NULL) {
- sub = (struct google_protobuf_MessageOptions*)_upb_Message_New(&google_protobuf_MessageOptions_msginit, arena);
+ sub = (struct google_protobuf_MessageOptions*)_upb_Message_New(&google_protobuf_MessageOptions_msg_init, arena);
if (!sub) return NULL;
google_protobuf_DescriptorProto_set_options(msg, sub);
}
@@ -2893,7 +3139,7 @@
return (google_protobuf_OneofDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(36, 72), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_OneofDescriptorProto* google_protobuf_DescriptorProto_add_oneof_decl(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_OneofDescriptorProto* sub = (struct google_protobuf_OneofDescriptorProto*)_upb_Message_New(&google_protobuf_OneofDescriptorProto_msginit, arena);
+ struct google_protobuf_OneofDescriptorProto* sub = (struct google_protobuf_OneofDescriptorProto*)_upb_Message_New(&google_protobuf_OneofDescriptorProto_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(36, 72), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -2905,7 +3151,7 @@
return (google_protobuf_DescriptorProto_ReservedRange**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(40, 80), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_DescriptorProto_ReservedRange* google_protobuf_DescriptorProto_add_reserved_range(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_DescriptorProto_ReservedRange* sub = (struct google_protobuf_DescriptorProto_ReservedRange*)_upb_Message_New(&google_protobuf_DescriptorProto_ReservedRange_msginit, arena);
+ struct google_protobuf_DescriptorProto_ReservedRange* sub = (struct google_protobuf_DescriptorProto_ReservedRange*)_upb_Message_New(&google_protobuf_DescriptorProto_ReservedRange_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(40, 80), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -2923,12 +3169,12 @@
/* google.protobuf.DescriptorProto.ExtensionRange */
UPB_INLINE google_protobuf_DescriptorProto_ExtensionRange* google_protobuf_DescriptorProto_ExtensionRange_new(upb_Arena* arena) {
- return (google_protobuf_DescriptorProto_ExtensionRange*)_upb_Message_New(&google_protobuf_DescriptorProto_ExtensionRange_msginit, arena);
+ return (google_protobuf_DescriptorProto_ExtensionRange*)_upb_Message_New(&google_protobuf_DescriptorProto_ExtensionRange_msg_init, arena);
}
UPB_INLINE google_protobuf_DescriptorProto_ExtensionRange* google_protobuf_DescriptorProto_ExtensionRange_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_DescriptorProto_ExtensionRange* ret = google_protobuf_DescriptorProto_ExtensionRange_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_ExtensionRange_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_ExtensionRange_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -2938,34 +3184,50 @@
int options, upb_Arena* arena) {
google_protobuf_DescriptorProto_ExtensionRange* ret = google_protobuf_DescriptorProto_ExtensionRange_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_ExtensionRange_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_ExtensionRange_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_DescriptorProto_ExtensionRange_serialize(const google_protobuf_DescriptorProto_ExtensionRange* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_DescriptorProto_ExtensionRange_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_DescriptorProto_ExtensionRange_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_DescriptorProto_ExtensionRange_serialize_ex(const google_protobuf_DescriptorProto_ExtensionRange* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_DescriptorProto_ExtensionRange_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_DescriptorProto_ExtensionRange_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_DescriptorProto_ExtensionRange_has_start(const google_protobuf_DescriptorProto_ExtensionRange* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_DescriptorProto_ExtensionRange_clear_start(const google_protobuf_DescriptorProto_ExtensionRange* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE int32_t google_protobuf_DescriptorProto_ExtensionRange_start(const google_protobuf_DescriptorProto_ExtensionRange* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
}
UPB_INLINE bool google_protobuf_DescriptorProto_ExtensionRange_has_end(const google_protobuf_DescriptorProto_ExtensionRange* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_DescriptorProto_ExtensionRange_clear_end(const google_protobuf_DescriptorProto_ExtensionRange* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = 0;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE int32_t google_protobuf_DescriptorProto_ExtensionRange_end(const google_protobuf_DescriptorProto_ExtensionRange* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t);
}
UPB_INLINE bool google_protobuf_DescriptorProto_ExtensionRange_has_options(const google_protobuf_DescriptorProto_ExtensionRange* msg) {
return _upb_hasbit(msg, 3);
}
+UPB_INLINE void google_protobuf_DescriptorProto_ExtensionRange_clear_options(const google_protobuf_DescriptorProto_ExtensionRange* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 16), const upb_Message*) = NULL;
+ _upb_clearhas(msg, 3);
+}
UPB_INLINE const google_protobuf_ExtensionRangeOptions* google_protobuf_DescriptorProto_ExtensionRange_options(const google_protobuf_DescriptorProto_ExtensionRange* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(12, 16), const google_protobuf_ExtensionRangeOptions*);
}
@@ -2985,7 +3247,7 @@
UPB_INLINE struct google_protobuf_ExtensionRangeOptions* google_protobuf_DescriptorProto_ExtensionRange_mutable_options(google_protobuf_DescriptorProto_ExtensionRange* msg, upb_Arena* arena) {
struct google_protobuf_ExtensionRangeOptions* sub = (struct google_protobuf_ExtensionRangeOptions*)google_protobuf_DescriptorProto_ExtensionRange_options(msg);
if (sub == NULL) {
- sub = (struct google_protobuf_ExtensionRangeOptions*)_upb_Message_New(&google_protobuf_ExtensionRangeOptions_msginit, arena);
+ sub = (struct google_protobuf_ExtensionRangeOptions*)_upb_Message_New(&google_protobuf_ExtensionRangeOptions_msg_init, arena);
if (!sub) return NULL;
google_protobuf_DescriptorProto_ExtensionRange_set_options(msg, sub);
}
@@ -2995,12 +3257,12 @@
/* google.protobuf.DescriptorProto.ReservedRange */
UPB_INLINE google_protobuf_DescriptorProto_ReservedRange* google_protobuf_DescriptorProto_ReservedRange_new(upb_Arena* arena) {
- return (google_protobuf_DescriptorProto_ReservedRange*)_upb_Message_New(&google_protobuf_DescriptorProto_ReservedRange_msginit, arena);
+ return (google_protobuf_DescriptorProto_ReservedRange*)_upb_Message_New(&google_protobuf_DescriptorProto_ReservedRange_msg_init, arena);
}
UPB_INLINE google_protobuf_DescriptorProto_ReservedRange* google_protobuf_DescriptorProto_ReservedRange_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_DescriptorProto_ReservedRange* ret = google_protobuf_DescriptorProto_ReservedRange_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_ReservedRange_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_ReservedRange_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -3010,28 +3272,40 @@
int options, upb_Arena* arena) {
google_protobuf_DescriptorProto_ReservedRange* ret = google_protobuf_DescriptorProto_ReservedRange_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_ReservedRange_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_DescriptorProto_ReservedRange_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_DescriptorProto_ReservedRange_serialize(const google_protobuf_DescriptorProto_ReservedRange* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_DescriptorProto_ReservedRange_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_DescriptorProto_ReservedRange_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_DescriptorProto_ReservedRange_serialize_ex(const google_protobuf_DescriptorProto_ReservedRange* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_DescriptorProto_ReservedRange_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_DescriptorProto_ReservedRange_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_DescriptorProto_ReservedRange_has_start(const google_protobuf_DescriptorProto_ReservedRange* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_DescriptorProto_ReservedRange_clear_start(const google_protobuf_DescriptorProto_ReservedRange* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE int32_t google_protobuf_DescriptorProto_ReservedRange_start(const google_protobuf_DescriptorProto_ReservedRange* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
}
UPB_INLINE bool google_protobuf_DescriptorProto_ReservedRange_has_end(const google_protobuf_DescriptorProto_ReservedRange* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_DescriptorProto_ReservedRange_clear_end(const google_protobuf_DescriptorProto_ReservedRange* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = 0;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE int32_t google_protobuf_DescriptorProto_ReservedRange_end(const google_protobuf_DescriptorProto_ReservedRange* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t);
}
@@ -3048,12 +3322,12 @@
/* google.protobuf.ExtensionRangeOptions */
UPB_INLINE google_protobuf_ExtensionRangeOptions* google_protobuf_ExtensionRangeOptions_new(upb_Arena* arena) {
- return (google_protobuf_ExtensionRangeOptions*)_upb_Message_New(&google_protobuf_ExtensionRangeOptions_msginit, arena);
+ return (google_protobuf_ExtensionRangeOptions*)_upb_Message_New(&google_protobuf_ExtensionRangeOptions_msg_init, arena);
}
UPB_INLINE google_protobuf_ExtensionRangeOptions* google_protobuf_ExtensionRangeOptions_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_ExtensionRangeOptions* ret = google_protobuf_ExtensionRangeOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_ExtensionRangeOptions_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_ExtensionRangeOptions_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -3063,22 +3337,29 @@
int options, upb_Arena* arena) {
google_protobuf_ExtensionRangeOptions* ret = google_protobuf_ExtensionRangeOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_ExtensionRangeOptions_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_ExtensionRangeOptions_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_ExtensionRangeOptions_serialize(const google_protobuf_ExtensionRangeOptions* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_ExtensionRangeOptions_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_ExtensionRangeOptions_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_ExtensionRangeOptions_serialize_ex(const google_protobuf_ExtensionRangeOptions* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_ExtensionRangeOptions_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_ExtensionRangeOptions_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_ExtensionRangeOptions_has_uninterpreted_option(const google_protobuf_ExtensionRangeOptions* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0));
}
+UPB_INLINE void google_protobuf_ExtensionRangeOptions_clear_uninterpreted_option(const google_protobuf_ExtensionRangeOptions* msg) {
+ _upb_array_detach(msg, UPB_SIZE(0, 0));
+}
UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_ExtensionRangeOptions_uninterpreted_option(const google_protobuf_ExtensionRangeOptions* msg, size_t* len) {
return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len);
}
@@ -3090,7 +3371,7 @@
return (google_protobuf_UninterpretedOption**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(0, 0), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_ExtensionRangeOptions_add_uninterpreted_option(google_protobuf_ExtensionRangeOptions* msg, upb_Arena* arena) {
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msginit, arena);
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(0, 0), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -3099,12 +3380,12 @@
/* google.protobuf.FieldDescriptorProto */
UPB_INLINE google_protobuf_FieldDescriptorProto* google_protobuf_FieldDescriptorProto_new(upb_Arena* arena) {
- return (google_protobuf_FieldDescriptorProto*)_upb_Message_New(&google_protobuf_FieldDescriptorProto_msginit, arena);
+ return (google_protobuf_FieldDescriptorProto*)_upb_Message_New(&google_protobuf_FieldDescriptorProto_msg_init, arena);
}
UPB_INLINE google_protobuf_FieldDescriptorProto* google_protobuf_FieldDescriptorProto_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_FieldDescriptorProto* ret = google_protobuf_FieldDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_FieldDescriptorProto_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_FieldDescriptorProto_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -3114,82 +3395,130 @@
int options, upb_Arena* arena) {
google_protobuf_FieldDescriptorProto* ret = google_protobuf_FieldDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_FieldDescriptorProto_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_FieldDescriptorProto_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_FieldDescriptorProto_serialize(const google_protobuf_FieldDescriptorProto* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_FieldDescriptorProto_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_FieldDescriptorProto_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_FieldDescriptorProto_serialize_ex(const google_protobuf_FieldDescriptorProto* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_FieldDescriptorProto_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_FieldDescriptorProto_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_name(const google_protobuf_FieldDescriptorProto* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_FieldDescriptorProto_clear_name(const google_protobuf_FieldDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(24, 24), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_FieldDescriptorProto_name(const google_protobuf_FieldDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), upb_StringView);
}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_extendee(const google_protobuf_FieldDescriptorProto* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_FieldDescriptorProto_clear_extendee(const google_protobuf_FieldDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(32, 40), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE upb_StringView google_protobuf_FieldDescriptorProto_extendee(const google_protobuf_FieldDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(32, 40), upb_StringView);
}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_number(const google_protobuf_FieldDescriptorProto* msg) {
return _upb_hasbit(msg, 3);
}
+UPB_INLINE void google_protobuf_FieldDescriptorProto_clear_number(const google_protobuf_FieldDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+ _upb_clearhas(msg, 3);
+}
UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_number(const google_protobuf_FieldDescriptorProto* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t);
+ return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_label(const google_protobuf_FieldDescriptorProto* msg) {
return _upb_hasbit(msg, 4);
}
+UPB_INLINE void google_protobuf_FieldDescriptorProto_clear_label(const google_protobuf_FieldDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = 0;
+ _upb_clearhas(msg, 4);
+}
UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_label(const google_protobuf_FieldDescriptorProto* msg) {
- return google_protobuf_FieldDescriptorProto_has_label(msg) ? *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) : 1;
+ return google_protobuf_FieldDescriptorProto_has_label(msg) ? *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) : 1;
}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_type(const google_protobuf_FieldDescriptorProto* msg) {
return _upb_hasbit(msg, 5);
}
+UPB_INLINE void google_protobuf_FieldDescriptorProto_clear_type(const google_protobuf_FieldDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t) = 0;
+ _upb_clearhas(msg, 5);
+}
UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_type(const google_protobuf_FieldDescriptorProto* msg) {
- return google_protobuf_FieldDescriptorProto_has_type(msg) ? *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) : 1;
+ return google_protobuf_FieldDescriptorProto_has_type(msg) ? *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t) : 1;
}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_type_name(const google_protobuf_FieldDescriptorProto* msg) {
return _upb_hasbit(msg, 6);
}
+UPB_INLINE void google_protobuf_FieldDescriptorProto_clear_type_name(const google_protobuf_FieldDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(40, 56), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 6);
+}
UPB_INLINE upb_StringView google_protobuf_FieldDescriptorProto_type_name(const google_protobuf_FieldDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(40, 56), upb_StringView);
}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_default_value(const google_protobuf_FieldDescriptorProto* msg) {
return _upb_hasbit(msg, 7);
}
+UPB_INLINE void google_protobuf_FieldDescriptorProto_clear_default_value(const google_protobuf_FieldDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(48, 72), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 7);
+}
UPB_INLINE upb_StringView google_protobuf_FieldDescriptorProto_default_value(const google_protobuf_FieldDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(48, 72), upb_StringView);
}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_options(const google_protobuf_FieldDescriptorProto* msg) {
return _upb_hasbit(msg, 8);
}
+UPB_INLINE void google_protobuf_FieldDescriptorProto_clear_options(const google_protobuf_FieldDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(56, 88), const upb_Message*) = NULL;
+ _upb_clearhas(msg, 8);
+}
UPB_INLINE const google_protobuf_FieldOptions* google_protobuf_FieldDescriptorProto_options(const google_protobuf_FieldDescriptorProto* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(64, 104), const google_protobuf_FieldOptions*);
+ return *UPB_PTR_AT(msg, UPB_SIZE(56, 88), const google_protobuf_FieldOptions*);
}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_oneof_index(const google_protobuf_FieldDescriptorProto* msg) {
return _upb_hasbit(msg, 9);
}
+UPB_INLINE void google_protobuf_FieldDescriptorProto_clear_oneof_index(const google_protobuf_FieldDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t) = 0;
+ _upb_clearhas(msg, 9);
+}
UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_oneof_index(const google_protobuf_FieldDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t);
}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_json_name(const google_protobuf_FieldDescriptorProto* msg) {
return _upb_hasbit(msg, 10);
}
+UPB_INLINE void google_protobuf_FieldDescriptorProto_clear_json_name(const google_protobuf_FieldDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(60, 96), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 10);
+}
UPB_INLINE upb_StringView google_protobuf_FieldDescriptorProto_json_name(const google_protobuf_FieldDescriptorProto* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(56, 88), upb_StringView);
+ return *UPB_PTR_AT(msg, UPB_SIZE(60, 96), upb_StringView);
}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_proto3_optional(const google_protobuf_FieldDescriptorProto* msg) {
return _upb_hasbit(msg, 11);
}
+UPB_INLINE void google_protobuf_FieldDescriptorProto_clear_proto3_optional(const google_protobuf_FieldDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(20, 20), bool) = 0;
+ _upb_clearhas(msg, 11);
+}
UPB_INLINE bool google_protobuf_FieldDescriptorProto_proto3_optional(const google_protobuf_FieldDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(20, 20), bool);
}
@@ -3204,15 +3533,15 @@
}
UPB_INLINE void google_protobuf_FieldDescriptorProto_set_number(google_protobuf_FieldDescriptorProto *msg, int32_t value) {
_upb_sethas(msg, 3);
- *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = value;
}
UPB_INLINE void google_protobuf_FieldDescriptorProto_set_label(google_protobuf_FieldDescriptorProto *msg, int32_t value) {
_upb_sethas(msg, 4);
- *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
}
UPB_INLINE void google_protobuf_FieldDescriptorProto_set_type(google_protobuf_FieldDescriptorProto *msg, int32_t value) {
_upb_sethas(msg, 5);
- *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t) = value;
}
UPB_INLINE void google_protobuf_FieldDescriptorProto_set_type_name(google_protobuf_FieldDescriptorProto *msg, upb_StringView value) {
_upb_sethas(msg, 6);
@@ -3224,12 +3553,12 @@
}
UPB_INLINE void google_protobuf_FieldDescriptorProto_set_options(google_protobuf_FieldDescriptorProto *msg, google_protobuf_FieldOptions* value) {
_upb_sethas(msg, 8);
- *UPB_PTR_AT(msg, UPB_SIZE(64, 104), google_protobuf_FieldOptions*) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(56, 88), google_protobuf_FieldOptions*) = value;
}
UPB_INLINE struct google_protobuf_FieldOptions* google_protobuf_FieldDescriptorProto_mutable_options(google_protobuf_FieldDescriptorProto* msg, upb_Arena* arena) {
struct google_protobuf_FieldOptions* sub = (struct google_protobuf_FieldOptions*)google_protobuf_FieldDescriptorProto_options(msg);
if (sub == NULL) {
- sub = (struct google_protobuf_FieldOptions*)_upb_Message_New(&google_protobuf_FieldOptions_msginit, arena);
+ sub = (struct google_protobuf_FieldOptions*)_upb_Message_New(&google_protobuf_FieldOptions_msg_init, arena);
if (!sub) return NULL;
google_protobuf_FieldDescriptorProto_set_options(msg, sub);
}
@@ -3241,7 +3570,7 @@
}
UPB_INLINE void google_protobuf_FieldDescriptorProto_set_json_name(google_protobuf_FieldDescriptorProto *msg, upb_StringView value) {
_upb_sethas(msg, 10);
- *UPB_PTR_AT(msg, UPB_SIZE(56, 88), upb_StringView) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(60, 96), upb_StringView) = value;
}
UPB_INLINE void google_protobuf_FieldDescriptorProto_set_proto3_optional(google_protobuf_FieldDescriptorProto *msg, bool value) {
_upb_sethas(msg, 11);
@@ -3251,12 +3580,12 @@
/* google.protobuf.OneofDescriptorProto */
UPB_INLINE google_protobuf_OneofDescriptorProto* google_protobuf_OneofDescriptorProto_new(upb_Arena* arena) {
- return (google_protobuf_OneofDescriptorProto*)_upb_Message_New(&google_protobuf_OneofDescriptorProto_msginit, arena);
+ return (google_protobuf_OneofDescriptorProto*)_upb_Message_New(&google_protobuf_OneofDescriptorProto_msg_init, arena);
}
UPB_INLINE google_protobuf_OneofDescriptorProto* google_protobuf_OneofDescriptorProto_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_OneofDescriptorProto* ret = google_protobuf_OneofDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_OneofDescriptorProto_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_OneofDescriptorProto_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -3266,28 +3595,40 @@
int options, upb_Arena* arena) {
google_protobuf_OneofDescriptorProto* ret = google_protobuf_OneofDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_OneofDescriptorProto_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_OneofDescriptorProto_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_OneofDescriptorProto_serialize(const google_protobuf_OneofDescriptorProto* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_OneofDescriptorProto_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_OneofDescriptorProto_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_OneofDescriptorProto_serialize_ex(const google_protobuf_OneofDescriptorProto* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_OneofDescriptorProto_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_OneofDescriptorProto_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_OneofDescriptorProto_has_name(const google_protobuf_OneofDescriptorProto* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_OneofDescriptorProto_clear_name(const google_protobuf_OneofDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_OneofDescriptorProto_name(const google_protobuf_OneofDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView);
}
UPB_INLINE bool google_protobuf_OneofDescriptorProto_has_options(const google_protobuf_OneofDescriptorProto* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_OneofDescriptorProto_clear_options(const google_protobuf_OneofDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const upb_Message*) = NULL;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE const google_protobuf_OneofOptions* google_protobuf_OneofDescriptorProto_options(const google_protobuf_OneofDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_OneofOptions*);
}
@@ -3303,7 +3644,7 @@
UPB_INLINE struct google_protobuf_OneofOptions* google_protobuf_OneofDescriptorProto_mutable_options(google_protobuf_OneofDescriptorProto* msg, upb_Arena* arena) {
struct google_protobuf_OneofOptions* sub = (struct google_protobuf_OneofOptions*)google_protobuf_OneofDescriptorProto_options(msg);
if (sub == NULL) {
- sub = (struct google_protobuf_OneofOptions*)_upb_Message_New(&google_protobuf_OneofOptions_msginit, arena);
+ sub = (struct google_protobuf_OneofOptions*)_upb_Message_New(&google_protobuf_OneofOptions_msg_init, arena);
if (!sub) return NULL;
google_protobuf_OneofDescriptorProto_set_options(msg, sub);
}
@@ -3313,12 +3654,12 @@
/* google.protobuf.EnumDescriptorProto */
UPB_INLINE google_protobuf_EnumDescriptorProto* google_protobuf_EnumDescriptorProto_new(upb_Arena* arena) {
- return (google_protobuf_EnumDescriptorProto*)_upb_Message_New(&google_protobuf_EnumDescriptorProto_msginit, arena);
+ return (google_protobuf_EnumDescriptorProto*)_upb_Message_New(&google_protobuf_EnumDescriptorProto_msg_init, arena);
}
UPB_INLINE google_protobuf_EnumDescriptorProto* google_protobuf_EnumDescriptorProto_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_EnumDescriptorProto* ret = google_protobuf_EnumDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_EnumDescriptorProto_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_EnumDescriptorProto_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -3328,43 +3669,64 @@
int options, upb_Arena* arena) {
google_protobuf_EnumDescriptorProto* ret = google_protobuf_EnumDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_EnumDescriptorProto_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_EnumDescriptorProto_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_EnumDescriptorProto_serialize(const google_protobuf_EnumDescriptorProto* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_EnumDescriptorProto_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_EnumDescriptorProto_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_EnumDescriptorProto_serialize_ex(const google_protobuf_EnumDescriptorProto* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_EnumDescriptorProto_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_EnumDescriptorProto_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_name(const google_protobuf_EnumDescriptorProto* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_EnumDescriptorProto_clear_name(const google_protobuf_EnumDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_EnumDescriptorProto_name(const google_protobuf_EnumDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView);
}
UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_value(const google_protobuf_EnumDescriptorProto* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(16, 32));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(12, 24));
+}
+UPB_INLINE void google_protobuf_EnumDescriptorProto_clear_value(const google_protobuf_EnumDescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(12, 24));
}
UPB_INLINE const google_protobuf_EnumValueDescriptorProto* const* google_protobuf_EnumDescriptorProto_value(const google_protobuf_EnumDescriptorProto* msg, size_t* len) {
- return (const google_protobuf_EnumValueDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(16, 32), len);
+ return (const google_protobuf_EnumValueDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(12, 24), len);
}
UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_options(const google_protobuf_EnumDescriptorProto* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_EnumDescriptorProto_clear_options(const google_protobuf_EnumDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 32), const upb_Message*) = NULL;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE const google_protobuf_EnumOptions* google_protobuf_EnumDescriptorProto_options(const google_protobuf_EnumDescriptorProto* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_EnumOptions*);
+ return *UPB_PTR_AT(msg, UPB_SIZE(16, 32), const google_protobuf_EnumOptions*);
}
UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_reserved_range(const google_protobuf_EnumDescriptorProto* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(20, 40));
}
+UPB_INLINE void google_protobuf_EnumDescriptorProto_clear_reserved_range(const google_protobuf_EnumDescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(20, 40));
+}
UPB_INLINE const google_protobuf_EnumDescriptorProto_EnumReservedRange* const* google_protobuf_EnumDescriptorProto_reserved_range(const google_protobuf_EnumDescriptorProto* msg, size_t* len) {
return (const google_protobuf_EnumDescriptorProto_EnumReservedRange* const*)_upb_array_accessor(msg, UPB_SIZE(20, 40), len);
}
+UPB_INLINE void google_protobuf_EnumDescriptorProto_clear_reserved_name(const google_protobuf_EnumDescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(24, 48));
+}
UPB_INLINE upb_StringView const* google_protobuf_EnumDescriptorProto_reserved_name(const google_protobuf_EnumDescriptorProto* msg, size_t* len) {
return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len);
}
@@ -3374,25 +3736,25 @@
*UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = value;
}
UPB_INLINE google_protobuf_EnumValueDescriptorProto** google_protobuf_EnumDescriptorProto_mutable_value(google_protobuf_EnumDescriptorProto* msg, size_t* len) {
- return (google_protobuf_EnumValueDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(16, 32), len);
+ return (google_protobuf_EnumValueDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(12, 24), len);
}
UPB_INLINE google_protobuf_EnumValueDescriptorProto** google_protobuf_EnumDescriptorProto_resize_value(google_protobuf_EnumDescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_EnumValueDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(16, 32), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_EnumValueDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(12, 24), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_EnumValueDescriptorProto* google_protobuf_EnumDescriptorProto_add_value(google_protobuf_EnumDescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_EnumValueDescriptorProto* sub = (struct google_protobuf_EnumValueDescriptorProto*)_upb_Message_New(&google_protobuf_EnumValueDescriptorProto_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(16, 32), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_EnumValueDescriptorProto* sub = (struct google_protobuf_EnumValueDescriptorProto*)_upb_Message_New(&google_protobuf_EnumValueDescriptorProto_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(12, 24), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE void google_protobuf_EnumDescriptorProto_set_options(google_protobuf_EnumDescriptorProto *msg, google_protobuf_EnumOptions* value) {
_upb_sethas(msg, 2);
- *UPB_PTR_AT(msg, UPB_SIZE(12, 24), google_protobuf_EnumOptions*) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 32), google_protobuf_EnumOptions*) = value;
}
UPB_INLINE struct google_protobuf_EnumOptions* google_protobuf_EnumDescriptorProto_mutable_options(google_protobuf_EnumDescriptorProto* msg, upb_Arena* arena) {
struct google_protobuf_EnumOptions* sub = (struct google_protobuf_EnumOptions*)google_protobuf_EnumDescriptorProto_options(msg);
if (sub == NULL) {
- sub = (struct google_protobuf_EnumOptions*)_upb_Message_New(&google_protobuf_EnumOptions_msginit, arena);
+ sub = (struct google_protobuf_EnumOptions*)_upb_Message_New(&google_protobuf_EnumOptions_msg_init, arena);
if (!sub) return NULL;
google_protobuf_EnumDescriptorProto_set_options(msg, sub);
}
@@ -3405,7 +3767,7 @@
return (google_protobuf_EnumDescriptorProto_EnumReservedRange**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(20, 40), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_EnumDescriptorProto_EnumReservedRange* google_protobuf_EnumDescriptorProto_add_reserved_range(google_protobuf_EnumDescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_EnumDescriptorProto_EnumReservedRange* sub = (struct google_protobuf_EnumDescriptorProto_EnumReservedRange*)_upb_Message_New(&google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit, arena);
+ struct google_protobuf_EnumDescriptorProto_EnumReservedRange* sub = (struct google_protobuf_EnumDescriptorProto_EnumReservedRange*)_upb_Message_New(&google_protobuf_EnumDescriptorProto_EnumReservedRange_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(20, 40), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -3423,12 +3785,12 @@
/* google.protobuf.EnumDescriptorProto.EnumReservedRange */
UPB_INLINE google_protobuf_EnumDescriptorProto_EnumReservedRange* google_protobuf_EnumDescriptorProto_EnumReservedRange_new(upb_Arena* arena) {
- return (google_protobuf_EnumDescriptorProto_EnumReservedRange*)_upb_Message_New(&google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit, arena);
+ return (google_protobuf_EnumDescriptorProto_EnumReservedRange*)_upb_Message_New(&google_protobuf_EnumDescriptorProto_EnumReservedRange_msg_init, arena);
}
UPB_INLINE google_protobuf_EnumDescriptorProto_EnumReservedRange* google_protobuf_EnumDescriptorProto_EnumReservedRange_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_EnumDescriptorProto_EnumReservedRange* ret = google_protobuf_EnumDescriptorProto_EnumReservedRange_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_EnumDescriptorProto_EnumReservedRange_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -3438,28 +3800,40 @@
int options, upb_Arena* arena) {
google_protobuf_EnumDescriptorProto_EnumReservedRange* ret = google_protobuf_EnumDescriptorProto_EnumReservedRange_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_EnumDescriptorProto_EnumReservedRange_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_EnumDescriptorProto_EnumReservedRange_serialize(const google_protobuf_EnumDescriptorProto_EnumReservedRange* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_EnumDescriptorProto_EnumReservedRange_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_EnumDescriptorProto_EnumReservedRange_serialize_ex(const google_protobuf_EnumDescriptorProto_EnumReservedRange* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_EnumDescriptorProto_EnumReservedRange_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_EnumDescriptorProto_EnumReservedRange_has_start(const google_protobuf_EnumDescriptorProto_EnumReservedRange* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_EnumDescriptorProto_EnumReservedRange_clear_start(const google_protobuf_EnumDescriptorProto_EnumReservedRange* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE int32_t google_protobuf_EnumDescriptorProto_EnumReservedRange_start(const google_protobuf_EnumDescriptorProto_EnumReservedRange* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
}
UPB_INLINE bool google_protobuf_EnumDescriptorProto_EnumReservedRange_has_end(const google_protobuf_EnumDescriptorProto_EnumReservedRange* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_EnumDescriptorProto_EnumReservedRange_clear_end(const google_protobuf_EnumDescriptorProto_EnumReservedRange* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = 0;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE int32_t google_protobuf_EnumDescriptorProto_EnumReservedRange_end(const google_protobuf_EnumDescriptorProto_EnumReservedRange* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t);
}
@@ -3476,12 +3850,12 @@
/* google.protobuf.EnumValueDescriptorProto */
UPB_INLINE google_protobuf_EnumValueDescriptorProto* google_protobuf_EnumValueDescriptorProto_new(upb_Arena* arena) {
- return (google_protobuf_EnumValueDescriptorProto*)_upb_Message_New(&google_protobuf_EnumValueDescriptorProto_msginit, arena);
+ return (google_protobuf_EnumValueDescriptorProto*)_upb_Message_New(&google_protobuf_EnumValueDescriptorProto_msg_init, arena);
}
UPB_INLINE google_protobuf_EnumValueDescriptorProto* google_protobuf_EnumValueDescriptorProto_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_EnumValueDescriptorProto* ret = google_protobuf_EnumValueDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_EnumValueDescriptorProto_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_EnumValueDescriptorProto_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -3491,34 +3865,50 @@
int options, upb_Arena* arena) {
google_protobuf_EnumValueDescriptorProto* ret = google_protobuf_EnumValueDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_EnumValueDescriptorProto_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_EnumValueDescriptorProto_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_EnumValueDescriptorProto_serialize(const google_protobuf_EnumValueDescriptorProto* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_EnumValueDescriptorProto_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_EnumValueDescriptorProto_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_EnumValueDescriptorProto_serialize_ex(const google_protobuf_EnumValueDescriptorProto* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_EnumValueDescriptorProto_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_EnumValueDescriptorProto_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_EnumValueDescriptorProto_has_name(const google_protobuf_EnumValueDescriptorProto* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_EnumValueDescriptorProto_clear_name(const google_protobuf_EnumValueDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_EnumValueDescriptorProto_name(const google_protobuf_EnumValueDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), upb_StringView);
}
UPB_INLINE bool google_protobuf_EnumValueDescriptorProto_has_number(const google_protobuf_EnumValueDescriptorProto* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_EnumValueDescriptorProto_clear_number(const google_protobuf_EnumValueDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE int32_t google_protobuf_EnumValueDescriptorProto_number(const google_protobuf_EnumValueDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
}
UPB_INLINE bool google_protobuf_EnumValueDescriptorProto_has_options(const google_protobuf_EnumValueDescriptorProto* msg) {
return _upb_hasbit(msg, 3);
}
+UPB_INLINE void google_protobuf_EnumValueDescriptorProto_clear_options(const google_protobuf_EnumValueDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 24), const upb_Message*) = NULL;
+ _upb_clearhas(msg, 3);
+}
UPB_INLINE const google_protobuf_EnumValueOptions* google_protobuf_EnumValueDescriptorProto_options(const google_protobuf_EnumValueDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), const google_protobuf_EnumValueOptions*);
}
@@ -3538,7 +3928,7 @@
UPB_INLINE struct google_protobuf_EnumValueOptions* google_protobuf_EnumValueDescriptorProto_mutable_options(google_protobuf_EnumValueDescriptorProto* msg, upb_Arena* arena) {
struct google_protobuf_EnumValueOptions* sub = (struct google_protobuf_EnumValueOptions*)google_protobuf_EnumValueDescriptorProto_options(msg);
if (sub == NULL) {
- sub = (struct google_protobuf_EnumValueOptions*)_upb_Message_New(&google_protobuf_EnumValueOptions_msginit, arena);
+ sub = (struct google_protobuf_EnumValueOptions*)_upb_Message_New(&google_protobuf_EnumValueOptions_msg_init, arena);
if (!sub) return NULL;
google_protobuf_EnumValueDescriptorProto_set_options(msg, sub);
}
@@ -3548,12 +3938,12 @@
/* google.protobuf.ServiceDescriptorProto */
UPB_INLINE google_protobuf_ServiceDescriptorProto* google_protobuf_ServiceDescriptorProto_new(upb_Arena* arena) {
- return (google_protobuf_ServiceDescriptorProto*)_upb_Message_New(&google_protobuf_ServiceDescriptorProto_msginit, arena);
+ return (google_protobuf_ServiceDescriptorProto*)_upb_Message_New(&google_protobuf_ServiceDescriptorProto_msg_init, arena);
}
UPB_INLINE google_protobuf_ServiceDescriptorProto* google_protobuf_ServiceDescriptorProto_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_ServiceDescriptorProto* ret = google_protobuf_ServiceDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_ServiceDescriptorProto_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_ServiceDescriptorProto_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -3563,36 +3953,51 @@
int options, upb_Arena* arena) {
google_protobuf_ServiceDescriptorProto* ret = google_protobuf_ServiceDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_ServiceDescriptorProto_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_ServiceDescriptorProto_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_ServiceDescriptorProto_serialize(const google_protobuf_ServiceDescriptorProto* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_ServiceDescriptorProto_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_ServiceDescriptorProto_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_ServiceDescriptorProto_serialize_ex(const google_protobuf_ServiceDescriptorProto* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_ServiceDescriptorProto_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_ServiceDescriptorProto_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_ServiceDescriptorProto_has_name(const google_protobuf_ServiceDescriptorProto* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_ServiceDescriptorProto_clear_name(const google_protobuf_ServiceDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_ServiceDescriptorProto_name(const google_protobuf_ServiceDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView);
}
UPB_INLINE bool google_protobuf_ServiceDescriptorProto_has_method(const google_protobuf_ServiceDescriptorProto* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(16, 32));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(12, 24));
+}
+UPB_INLINE void google_protobuf_ServiceDescriptorProto_clear_method(const google_protobuf_ServiceDescriptorProto* msg) {
+ _upb_array_detach(msg, UPB_SIZE(12, 24));
}
UPB_INLINE const google_protobuf_MethodDescriptorProto* const* google_protobuf_ServiceDescriptorProto_method(const google_protobuf_ServiceDescriptorProto* msg, size_t* len) {
- return (const google_protobuf_MethodDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(16, 32), len);
+ return (const google_protobuf_MethodDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(12, 24), len);
}
UPB_INLINE bool google_protobuf_ServiceDescriptorProto_has_options(const google_protobuf_ServiceDescriptorProto* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_ServiceDescriptorProto_clear_options(const google_protobuf_ServiceDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 32), const upb_Message*) = NULL;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE const google_protobuf_ServiceOptions* google_protobuf_ServiceDescriptorProto_options(const google_protobuf_ServiceDescriptorProto* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_ServiceOptions*);
+ return *UPB_PTR_AT(msg, UPB_SIZE(16, 32), const google_protobuf_ServiceOptions*);
}
UPB_INLINE void google_protobuf_ServiceDescriptorProto_set_name(google_protobuf_ServiceDescriptorProto *msg, upb_StringView value) {
@@ -3600,25 +4005,25 @@
*UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = value;
}
UPB_INLINE google_protobuf_MethodDescriptorProto** google_protobuf_ServiceDescriptorProto_mutable_method(google_protobuf_ServiceDescriptorProto* msg, size_t* len) {
- return (google_protobuf_MethodDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(16, 32), len);
+ return (google_protobuf_MethodDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(12, 24), len);
}
UPB_INLINE google_protobuf_MethodDescriptorProto** google_protobuf_ServiceDescriptorProto_resize_method(google_protobuf_ServiceDescriptorProto* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_MethodDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(16, 32), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_MethodDescriptorProto**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(12, 24), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_MethodDescriptorProto* google_protobuf_ServiceDescriptorProto_add_method(google_protobuf_ServiceDescriptorProto* msg, upb_Arena* arena) {
- struct google_protobuf_MethodDescriptorProto* sub = (struct google_protobuf_MethodDescriptorProto*)_upb_Message_New(&google_protobuf_MethodDescriptorProto_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(16, 32), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_MethodDescriptorProto* sub = (struct google_protobuf_MethodDescriptorProto*)_upb_Message_New(&google_protobuf_MethodDescriptorProto_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(12, 24), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE void google_protobuf_ServiceDescriptorProto_set_options(google_protobuf_ServiceDescriptorProto *msg, google_protobuf_ServiceOptions* value) {
_upb_sethas(msg, 2);
- *UPB_PTR_AT(msg, UPB_SIZE(12, 24), google_protobuf_ServiceOptions*) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 32), google_protobuf_ServiceOptions*) = value;
}
UPB_INLINE struct google_protobuf_ServiceOptions* google_protobuf_ServiceDescriptorProto_mutable_options(google_protobuf_ServiceDescriptorProto* msg, upb_Arena* arena) {
struct google_protobuf_ServiceOptions* sub = (struct google_protobuf_ServiceOptions*)google_protobuf_ServiceDescriptorProto_options(msg);
if (sub == NULL) {
- sub = (struct google_protobuf_ServiceOptions*)_upb_Message_New(&google_protobuf_ServiceOptions_msginit, arena);
+ sub = (struct google_protobuf_ServiceOptions*)_upb_Message_New(&google_protobuf_ServiceOptions_msg_init, arena);
if (!sub) return NULL;
google_protobuf_ServiceDescriptorProto_set_options(msg, sub);
}
@@ -3628,12 +4033,12 @@
/* google.protobuf.MethodDescriptorProto */
UPB_INLINE google_protobuf_MethodDescriptorProto* google_protobuf_MethodDescriptorProto_new(upb_Arena* arena) {
- return (google_protobuf_MethodDescriptorProto*)_upb_Message_New(&google_protobuf_MethodDescriptorProto_msginit, arena);
+ return (google_protobuf_MethodDescriptorProto*)_upb_Message_New(&google_protobuf_MethodDescriptorProto_msg_init, arena);
}
UPB_INLINE google_protobuf_MethodDescriptorProto* google_protobuf_MethodDescriptorProto_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_MethodDescriptorProto* ret = google_protobuf_MethodDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_MethodDescriptorProto_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_MethodDescriptorProto_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -3643,52 +4048,80 @@
int options, upb_Arena* arena) {
google_protobuf_MethodDescriptorProto* ret = google_protobuf_MethodDescriptorProto_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_MethodDescriptorProto_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_MethodDescriptorProto_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_MethodDescriptorProto_serialize(const google_protobuf_MethodDescriptorProto* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_MethodDescriptorProto_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_MethodDescriptorProto_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_MethodDescriptorProto_serialize_ex(const google_protobuf_MethodDescriptorProto* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_MethodDescriptorProto_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_MethodDescriptorProto_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_name(const google_protobuf_MethodDescriptorProto* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_MethodDescriptorProto_clear_name(const google_protobuf_MethodDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_MethodDescriptorProto_name(const google_protobuf_MethodDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView);
}
UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_input_type(const google_protobuf_MethodDescriptorProto* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_MethodDescriptorProto_clear_input_type(const google_protobuf_MethodDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE upb_StringView google_protobuf_MethodDescriptorProto_input_type(const google_protobuf_MethodDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_StringView);
}
UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_output_type(const google_protobuf_MethodDescriptorProto* msg) {
return _upb_hasbit(msg, 3);
}
+UPB_INLINE void google_protobuf_MethodDescriptorProto_clear_output_type(const google_protobuf_MethodDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 3);
+}
UPB_INLINE upb_StringView google_protobuf_MethodDescriptorProto_output_type(const google_protobuf_MethodDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_StringView);
}
UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_options(const google_protobuf_MethodDescriptorProto* msg) {
return _upb_hasbit(msg, 4);
}
+UPB_INLINE void google_protobuf_MethodDescriptorProto_clear_options(const google_protobuf_MethodDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(28, 56), const upb_Message*) = NULL;
+ _upb_clearhas(msg, 4);
+}
UPB_INLINE const google_protobuf_MethodOptions* google_protobuf_MethodDescriptorProto_options(const google_protobuf_MethodDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(28, 56), const google_protobuf_MethodOptions*);
}
UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_client_streaming(const google_protobuf_MethodDescriptorProto* msg) {
return _upb_hasbit(msg, 5);
}
+UPB_INLINE void google_protobuf_MethodDescriptorProto_clear_client_streaming(const google_protobuf_MethodDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+ _upb_clearhas(msg, 5);
+}
UPB_INLINE bool google_protobuf_MethodDescriptorProto_client_streaming(const google_protobuf_MethodDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
}
UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_server_streaming(const google_protobuf_MethodDescriptorProto* msg) {
return _upb_hasbit(msg, 6);
}
+UPB_INLINE void google_protobuf_MethodDescriptorProto_clear_server_streaming(const google_protobuf_MethodDescriptorProto* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = 0;
+ _upb_clearhas(msg, 6);
+}
UPB_INLINE bool google_protobuf_MethodDescriptorProto_server_streaming(const google_protobuf_MethodDescriptorProto* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool);
}
@@ -3712,7 +4145,7 @@
UPB_INLINE struct google_protobuf_MethodOptions* google_protobuf_MethodDescriptorProto_mutable_options(google_protobuf_MethodDescriptorProto* msg, upb_Arena* arena) {
struct google_protobuf_MethodOptions* sub = (struct google_protobuf_MethodOptions*)google_protobuf_MethodDescriptorProto_options(msg);
if (sub == NULL) {
- sub = (struct google_protobuf_MethodOptions*)_upb_Message_New(&google_protobuf_MethodOptions_msginit, arena);
+ sub = (struct google_protobuf_MethodOptions*)_upb_Message_New(&google_protobuf_MethodOptions_msg_init, arena);
if (!sub) return NULL;
google_protobuf_MethodDescriptorProto_set_options(msg, sub);
}
@@ -3730,12 +4163,12 @@
/* google.protobuf.FileOptions */
UPB_INLINE google_protobuf_FileOptions* google_protobuf_FileOptions_new(upb_Arena* arena) {
- return (google_protobuf_FileOptions*)_upb_Message_New(&google_protobuf_FileOptions_msginit, arena);
+ return (google_protobuf_FileOptions*)_upb_Message_New(&google_protobuf_FileOptions_msg_init, arena);
}
UPB_INLINE google_protobuf_FileOptions* google_protobuf_FileOptions_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_FileOptions* ret = google_protobuf_FileOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_FileOptions_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_FileOptions_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -3745,142 +4178,229 @@
int options, upb_Arena* arena) {
google_protobuf_FileOptions* ret = google_protobuf_FileOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_FileOptions_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_FileOptions_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_FileOptions_serialize(const google_protobuf_FileOptions* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_FileOptions_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_FileOptions_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_FileOptions_serialize_ex(const google_protobuf_FileOptions* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_FileOptions_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_FileOptions_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_FileOptions_has_java_package(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_java_package(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(20, 24), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_FileOptions_java_package(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(20, 24), upb_StringView);
}
UPB_INLINE bool google_protobuf_FileOptions_has_java_outer_classname(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_java_outer_classname(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(28, 40), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE upb_StringView google_protobuf_FileOptions_java_outer_classname(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(28, 40), upb_StringView);
}
UPB_INLINE bool google_protobuf_FileOptions_has_optimize_for(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 3);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_optimize_for(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+ _upb_clearhas(msg, 3);
+}
UPB_INLINE int32_t google_protobuf_FileOptions_optimize_for(const google_protobuf_FileOptions* msg) {
return google_protobuf_FileOptions_has_optimize_for(msg) ? *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) : 1;
}
UPB_INLINE bool google_protobuf_FileOptions_has_java_multiple_files(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 4);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_java_multiple_files(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool) = 0;
+ _upb_clearhas(msg, 4);
+}
UPB_INLINE bool google_protobuf_FileOptions_java_multiple_files(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool);
}
UPB_INLINE bool google_protobuf_FileOptions_has_go_package(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 5);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_go_package(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(36, 56), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 5);
+}
UPB_INLINE upb_StringView google_protobuf_FileOptions_go_package(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(36, 56), upb_StringView);
}
UPB_INLINE bool google_protobuf_FileOptions_has_cc_generic_services(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 6);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_cc_generic_services(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(9, 9), bool) = 0;
+ _upb_clearhas(msg, 6);
+}
UPB_INLINE bool google_protobuf_FileOptions_cc_generic_services(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(9, 9), bool);
}
UPB_INLINE bool google_protobuf_FileOptions_has_java_generic_services(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 7);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_java_generic_services(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(10, 10), bool) = 0;
+ _upb_clearhas(msg, 7);
+}
UPB_INLINE bool google_protobuf_FileOptions_java_generic_services(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(10, 10), bool);
}
UPB_INLINE bool google_protobuf_FileOptions_has_py_generic_services(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 8);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_py_generic_services(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(11, 11), bool) = 0;
+ _upb_clearhas(msg, 8);
+}
UPB_INLINE bool google_protobuf_FileOptions_py_generic_services(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(11, 11), bool);
}
UPB_INLINE bool google_protobuf_FileOptions_has_java_generate_equals_and_hash(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 9);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_java_generate_equals_and_hash(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 12), bool) = 0;
+ _upb_clearhas(msg, 9);
+}
UPB_INLINE bool google_protobuf_FileOptions_java_generate_equals_and_hash(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(12, 12), bool);
}
UPB_INLINE bool google_protobuf_FileOptions_has_deprecated(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 10);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_deprecated(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(13, 13), bool) = 0;
+ _upb_clearhas(msg, 10);
+}
UPB_INLINE bool google_protobuf_FileOptions_deprecated(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(13, 13), bool);
}
UPB_INLINE bool google_protobuf_FileOptions_has_java_string_check_utf8(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 11);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_java_string_check_utf8(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(14, 14), bool) = 0;
+ _upb_clearhas(msg, 11);
+}
UPB_INLINE bool google_protobuf_FileOptions_java_string_check_utf8(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(14, 14), bool);
}
UPB_INLINE bool google_protobuf_FileOptions_has_cc_enable_arenas(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 12);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_cc_enable_arenas(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(15, 15), bool) = 0;
+ _upb_clearhas(msg, 12);
+}
UPB_INLINE bool google_protobuf_FileOptions_cc_enable_arenas(const google_protobuf_FileOptions* msg) {
return google_protobuf_FileOptions_has_cc_enable_arenas(msg) ? *UPB_PTR_AT(msg, UPB_SIZE(15, 15), bool) : true;
}
UPB_INLINE bool google_protobuf_FileOptions_has_objc_class_prefix(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 13);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_objc_class_prefix(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(44, 72), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 13);
+}
UPB_INLINE upb_StringView google_protobuf_FileOptions_objc_class_prefix(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(44, 72), upb_StringView);
}
UPB_INLINE bool google_protobuf_FileOptions_has_csharp_namespace(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 14);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_csharp_namespace(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(52, 88), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 14);
+}
UPB_INLINE upb_StringView google_protobuf_FileOptions_csharp_namespace(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(52, 88), upb_StringView);
}
UPB_INLINE bool google_protobuf_FileOptions_has_swift_prefix(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 15);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_swift_prefix(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(60, 104), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 15);
+}
UPB_INLINE upb_StringView google_protobuf_FileOptions_swift_prefix(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(60, 104), upb_StringView);
}
UPB_INLINE bool google_protobuf_FileOptions_has_php_class_prefix(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 16);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_php_class_prefix(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(68, 120), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 16);
+}
UPB_INLINE upb_StringView google_protobuf_FileOptions_php_class_prefix(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(68, 120), upb_StringView);
}
UPB_INLINE bool google_protobuf_FileOptions_has_php_namespace(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 17);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_php_namespace(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(76, 136), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 17);
+}
UPB_INLINE upb_StringView google_protobuf_FileOptions_php_namespace(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(76, 136), upb_StringView);
}
UPB_INLINE bool google_protobuf_FileOptions_has_php_generic_services(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 18);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_php_generic_services(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool) = 0;
+ _upb_clearhas(msg, 18);
+}
UPB_INLINE bool google_protobuf_FileOptions_php_generic_services(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool);
}
UPB_INLINE bool google_protobuf_FileOptions_has_php_metadata_namespace(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 19);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_php_metadata_namespace(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(84, 152), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 19);
+}
UPB_INLINE upb_StringView google_protobuf_FileOptions_php_metadata_namespace(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(84, 152), upb_StringView);
}
UPB_INLINE bool google_protobuf_FileOptions_has_ruby_package(const google_protobuf_FileOptions* msg) {
return _upb_hasbit(msg, 20);
}
+UPB_INLINE void google_protobuf_FileOptions_clear_ruby_package(const google_protobuf_FileOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(92, 168), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 20);
+}
UPB_INLINE upb_StringView google_protobuf_FileOptions_ruby_package(const google_protobuf_FileOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(92, 168), upb_StringView);
}
UPB_INLINE bool google_protobuf_FileOptions_has_uninterpreted_option(const google_protobuf_FileOptions* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(100, 184));
}
+UPB_INLINE void google_protobuf_FileOptions_clear_uninterpreted_option(const google_protobuf_FileOptions* msg) {
+ _upb_array_detach(msg, UPB_SIZE(100, 184));
+}
UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_FileOptions_uninterpreted_option(const google_protobuf_FileOptions* msg, size_t* len) {
return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(100, 184), len);
}
@@ -3972,7 +4492,7 @@
return (google_protobuf_UninterpretedOption**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(100, 184), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_FileOptions_add_uninterpreted_option(google_protobuf_FileOptions* msg, upb_Arena* arena) {
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msginit, arena);
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(100, 184), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -3981,12 +4501,12 @@
/* google.protobuf.MessageOptions */
UPB_INLINE google_protobuf_MessageOptions* google_protobuf_MessageOptions_new(upb_Arena* arena) {
- return (google_protobuf_MessageOptions*)_upb_Message_New(&google_protobuf_MessageOptions_msginit, arena);
+ return (google_protobuf_MessageOptions*)_upb_Message_New(&google_protobuf_MessageOptions_msg_init, arena);
}
UPB_INLINE google_protobuf_MessageOptions* google_protobuf_MessageOptions_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_MessageOptions* ret = google_protobuf_MessageOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_MessageOptions_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_MessageOptions_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -3996,46 +4516,69 @@
int options, upb_Arena* arena) {
google_protobuf_MessageOptions* ret = google_protobuf_MessageOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_MessageOptions_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_MessageOptions_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_MessageOptions_serialize(const google_protobuf_MessageOptions* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_MessageOptions_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_MessageOptions_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_MessageOptions_serialize_ex(const google_protobuf_MessageOptions* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_MessageOptions_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_MessageOptions_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_MessageOptions_has_message_set_wire_format(const google_protobuf_MessageOptions* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_MessageOptions_clear_message_set_wire_format(const google_protobuf_MessageOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE bool google_protobuf_MessageOptions_message_set_wire_format(const google_protobuf_MessageOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
}
UPB_INLINE bool google_protobuf_MessageOptions_has_no_standard_descriptor_accessor(const google_protobuf_MessageOptions* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_MessageOptions_clear_no_standard_descriptor_accessor(const google_protobuf_MessageOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = 0;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE bool google_protobuf_MessageOptions_no_standard_descriptor_accessor(const google_protobuf_MessageOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool);
}
UPB_INLINE bool google_protobuf_MessageOptions_has_deprecated(const google_protobuf_MessageOptions* msg) {
return _upb_hasbit(msg, 3);
}
+UPB_INLINE void google_protobuf_MessageOptions_clear_deprecated(const google_protobuf_MessageOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(3, 3), bool) = 0;
+ _upb_clearhas(msg, 3);
+}
UPB_INLINE bool google_protobuf_MessageOptions_deprecated(const google_protobuf_MessageOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(3, 3), bool);
}
UPB_INLINE bool google_protobuf_MessageOptions_has_map_entry(const google_protobuf_MessageOptions* msg) {
return _upb_hasbit(msg, 4);
}
+UPB_INLINE void google_protobuf_MessageOptions_clear_map_entry(const google_protobuf_MessageOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), bool) = 0;
+ _upb_clearhas(msg, 4);
+}
UPB_INLINE bool google_protobuf_MessageOptions_map_entry(const google_protobuf_MessageOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), bool);
}
UPB_INLINE bool google_protobuf_MessageOptions_has_uninterpreted_option(const google_protobuf_MessageOptions* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(8, 8));
}
+UPB_INLINE void google_protobuf_MessageOptions_clear_uninterpreted_option(const google_protobuf_MessageOptions* msg) {
+ _upb_array_detach(msg, UPB_SIZE(8, 8));
+}
UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_MessageOptions_uninterpreted_option(const google_protobuf_MessageOptions* msg, size_t* len) {
return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(8, 8), len);
}
@@ -4063,7 +4606,7 @@
return (google_protobuf_UninterpretedOption**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(8, 8), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_MessageOptions_add_uninterpreted_option(google_protobuf_MessageOptions* msg, upb_Arena* arena) {
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msginit, arena);
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 8), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -4072,12 +4615,12 @@
/* google.protobuf.FieldOptions */
UPB_INLINE google_protobuf_FieldOptions* google_protobuf_FieldOptions_new(upb_Arena* arena) {
- return (google_protobuf_FieldOptions*)_upb_Message_New(&google_protobuf_FieldOptions_msginit, arena);
+ return (google_protobuf_FieldOptions*)_upb_Message_New(&google_protobuf_FieldOptions_msg_init, arena);
}
UPB_INLINE google_protobuf_FieldOptions* google_protobuf_FieldOptions_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_FieldOptions* ret = google_protobuf_FieldOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_FieldOptions_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_FieldOptions_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4087,64 +4630,99 @@
int options, upb_Arena* arena) {
google_protobuf_FieldOptions* ret = google_protobuf_FieldOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_FieldOptions_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_FieldOptions_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_FieldOptions_serialize(const google_protobuf_FieldOptions* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_FieldOptions_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_FieldOptions_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_FieldOptions_serialize_ex(const google_protobuf_FieldOptions* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_FieldOptions_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_FieldOptions_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_FieldOptions_has_ctype(const google_protobuf_FieldOptions* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_FieldOptions_clear_ctype(const google_protobuf_FieldOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE int32_t google_protobuf_FieldOptions_ctype(const google_protobuf_FieldOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
}
UPB_INLINE bool google_protobuf_FieldOptions_has_packed(const google_protobuf_FieldOptions* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_FieldOptions_clear_packed(const google_protobuf_FieldOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool) = 0;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE bool google_protobuf_FieldOptions_packed(const google_protobuf_FieldOptions* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(12, 12), bool);
+ return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool);
}
UPB_INLINE bool google_protobuf_FieldOptions_has_deprecated(const google_protobuf_FieldOptions* msg) {
return _upb_hasbit(msg, 3);
}
+UPB_INLINE void google_protobuf_FieldOptions_clear_deprecated(const google_protobuf_FieldOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(9, 9), bool) = 0;
+ _upb_clearhas(msg, 3);
+}
UPB_INLINE bool google_protobuf_FieldOptions_deprecated(const google_protobuf_FieldOptions* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(13, 13), bool);
+ return *UPB_PTR_AT(msg, UPB_SIZE(9, 9), bool);
}
UPB_INLINE bool google_protobuf_FieldOptions_has_lazy(const google_protobuf_FieldOptions* msg) {
return _upb_hasbit(msg, 4);
}
+UPB_INLINE void google_protobuf_FieldOptions_clear_lazy(const google_protobuf_FieldOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(10, 10), bool) = 0;
+ _upb_clearhas(msg, 4);
+}
UPB_INLINE bool google_protobuf_FieldOptions_lazy(const google_protobuf_FieldOptions* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(14, 14), bool);
+ return *UPB_PTR_AT(msg, UPB_SIZE(10, 10), bool);
}
UPB_INLINE bool google_protobuf_FieldOptions_has_jstype(const google_protobuf_FieldOptions* msg) {
return _upb_hasbit(msg, 5);
}
+UPB_INLINE void google_protobuf_FieldOptions_clear_jstype(const google_protobuf_FieldOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t) = 0;
+ _upb_clearhas(msg, 5);
+}
UPB_INLINE int32_t google_protobuf_FieldOptions_jstype(const google_protobuf_FieldOptions* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t);
+ return *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t);
}
UPB_INLINE bool google_protobuf_FieldOptions_has_weak(const google_protobuf_FieldOptions* msg) {
return _upb_hasbit(msg, 6);
}
+UPB_INLINE void google_protobuf_FieldOptions_clear_weak(const google_protobuf_FieldOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool) = 0;
+ _upb_clearhas(msg, 6);
+}
UPB_INLINE bool google_protobuf_FieldOptions_weak(const google_protobuf_FieldOptions* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(15, 15), bool);
+ return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool);
}
UPB_INLINE bool google_protobuf_FieldOptions_has_unverified_lazy(const google_protobuf_FieldOptions* msg) {
return _upb_hasbit(msg, 7);
}
+UPB_INLINE void google_protobuf_FieldOptions_clear_unverified_lazy(const google_protobuf_FieldOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(17, 17), bool) = 0;
+ _upb_clearhas(msg, 7);
+}
UPB_INLINE bool google_protobuf_FieldOptions_unverified_lazy(const google_protobuf_FieldOptions* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool);
+ return *UPB_PTR_AT(msg, UPB_SIZE(17, 17), bool);
}
UPB_INLINE bool google_protobuf_FieldOptions_has_uninterpreted_option(const google_protobuf_FieldOptions* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(20, 24));
}
+UPB_INLINE void google_protobuf_FieldOptions_clear_uninterpreted_option(const google_protobuf_FieldOptions* msg) {
+ _upb_array_detach(msg, UPB_SIZE(20, 24));
+}
UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_FieldOptions_uninterpreted_option(const google_protobuf_FieldOptions* msg, size_t* len) {
return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(20, 24), len);
}
@@ -4155,27 +4733,27 @@
}
UPB_INLINE void google_protobuf_FieldOptions_set_packed(google_protobuf_FieldOptions *msg, bool value) {
_upb_sethas(msg, 2);
- *UPB_PTR_AT(msg, UPB_SIZE(12, 12), bool) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool) = value;
}
UPB_INLINE void google_protobuf_FieldOptions_set_deprecated(google_protobuf_FieldOptions *msg, bool value) {
_upb_sethas(msg, 3);
- *UPB_PTR_AT(msg, UPB_SIZE(13, 13), bool) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(9, 9), bool) = value;
}
UPB_INLINE void google_protobuf_FieldOptions_set_lazy(google_protobuf_FieldOptions *msg, bool value) {
_upb_sethas(msg, 4);
- *UPB_PTR_AT(msg, UPB_SIZE(14, 14), bool) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(10, 10), bool) = value;
}
UPB_INLINE void google_protobuf_FieldOptions_set_jstype(google_protobuf_FieldOptions *msg, int32_t value) {
_upb_sethas(msg, 5);
- *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t) = value;
}
UPB_INLINE void google_protobuf_FieldOptions_set_weak(google_protobuf_FieldOptions *msg, bool value) {
_upb_sethas(msg, 6);
- *UPB_PTR_AT(msg, UPB_SIZE(15, 15), bool) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool) = value;
}
UPB_INLINE void google_protobuf_FieldOptions_set_unverified_lazy(google_protobuf_FieldOptions *msg, bool value) {
_upb_sethas(msg, 7);
- *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(17, 17), bool) = value;
}
UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_FieldOptions_mutable_uninterpreted_option(google_protobuf_FieldOptions* msg, size_t* len) {
return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(20, 24), len);
@@ -4184,7 +4762,7 @@
return (google_protobuf_UninterpretedOption**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(20, 24), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_FieldOptions_add_uninterpreted_option(google_protobuf_FieldOptions* msg, upb_Arena* arena) {
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msginit, arena);
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(20, 24), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -4193,12 +4771,12 @@
/* google.protobuf.OneofOptions */
UPB_INLINE google_protobuf_OneofOptions* google_protobuf_OneofOptions_new(upb_Arena* arena) {
- return (google_protobuf_OneofOptions*)_upb_Message_New(&google_protobuf_OneofOptions_msginit, arena);
+ return (google_protobuf_OneofOptions*)_upb_Message_New(&google_protobuf_OneofOptions_msg_init, arena);
}
UPB_INLINE google_protobuf_OneofOptions* google_protobuf_OneofOptions_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_OneofOptions* ret = google_protobuf_OneofOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_OneofOptions_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_OneofOptions_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4208,22 +4786,29 @@
int options, upb_Arena* arena) {
google_protobuf_OneofOptions* ret = google_protobuf_OneofOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_OneofOptions_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_OneofOptions_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_OneofOptions_serialize(const google_protobuf_OneofOptions* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_OneofOptions_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_OneofOptions_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_OneofOptions_serialize_ex(const google_protobuf_OneofOptions* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_OneofOptions_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_OneofOptions_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_OneofOptions_has_uninterpreted_option(const google_protobuf_OneofOptions* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0));
}
+UPB_INLINE void google_protobuf_OneofOptions_clear_uninterpreted_option(const google_protobuf_OneofOptions* msg) {
+ _upb_array_detach(msg, UPB_SIZE(0, 0));
+}
UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_OneofOptions_uninterpreted_option(const google_protobuf_OneofOptions* msg, size_t* len) {
return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len);
}
@@ -4235,7 +4820,7 @@
return (google_protobuf_UninterpretedOption**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(0, 0), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_OneofOptions_add_uninterpreted_option(google_protobuf_OneofOptions* msg, upb_Arena* arena) {
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msginit, arena);
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(0, 0), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -4244,12 +4829,12 @@
/* google.protobuf.EnumOptions */
UPB_INLINE google_protobuf_EnumOptions* google_protobuf_EnumOptions_new(upb_Arena* arena) {
- return (google_protobuf_EnumOptions*)_upb_Message_New(&google_protobuf_EnumOptions_msginit, arena);
+ return (google_protobuf_EnumOptions*)_upb_Message_New(&google_protobuf_EnumOptions_msg_init, arena);
}
UPB_INLINE google_protobuf_EnumOptions* google_protobuf_EnumOptions_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_EnumOptions* ret = google_protobuf_EnumOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_EnumOptions_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_EnumOptions_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4259,34 +4844,49 @@
int options, upb_Arena* arena) {
google_protobuf_EnumOptions* ret = google_protobuf_EnumOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_EnumOptions_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_EnumOptions_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_EnumOptions_serialize(const google_protobuf_EnumOptions* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_EnumOptions_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_EnumOptions_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_EnumOptions_serialize_ex(const google_protobuf_EnumOptions* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_EnumOptions_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_EnumOptions_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_EnumOptions_has_allow_alias(const google_protobuf_EnumOptions* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_EnumOptions_clear_allow_alias(const google_protobuf_EnumOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE bool google_protobuf_EnumOptions_allow_alias(const google_protobuf_EnumOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
}
UPB_INLINE bool google_protobuf_EnumOptions_has_deprecated(const google_protobuf_EnumOptions* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_EnumOptions_clear_deprecated(const google_protobuf_EnumOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = 0;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE bool google_protobuf_EnumOptions_deprecated(const google_protobuf_EnumOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool);
}
UPB_INLINE bool google_protobuf_EnumOptions_has_uninterpreted_option(const google_protobuf_EnumOptions* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(4, 8));
}
+UPB_INLINE void google_protobuf_EnumOptions_clear_uninterpreted_option(const google_protobuf_EnumOptions* msg) {
+ _upb_array_detach(msg, UPB_SIZE(4, 8));
+}
UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_EnumOptions_uninterpreted_option(const google_protobuf_EnumOptions* msg, size_t* len) {
return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
}
@@ -4306,7 +4906,7 @@
return (google_protobuf_UninterpretedOption**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_EnumOptions_add_uninterpreted_option(google_protobuf_EnumOptions* msg, upb_Arena* arena) {
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msginit, arena);
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -4315,12 +4915,12 @@
/* google.protobuf.EnumValueOptions */
UPB_INLINE google_protobuf_EnumValueOptions* google_protobuf_EnumValueOptions_new(upb_Arena* arena) {
- return (google_protobuf_EnumValueOptions*)_upb_Message_New(&google_protobuf_EnumValueOptions_msginit, arena);
+ return (google_protobuf_EnumValueOptions*)_upb_Message_New(&google_protobuf_EnumValueOptions_msg_init, arena);
}
UPB_INLINE google_protobuf_EnumValueOptions* google_protobuf_EnumValueOptions_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_EnumValueOptions* ret = google_protobuf_EnumValueOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_EnumValueOptions_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_EnumValueOptions_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4330,28 +4930,39 @@
int options, upb_Arena* arena) {
google_protobuf_EnumValueOptions* ret = google_protobuf_EnumValueOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_EnumValueOptions_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_EnumValueOptions_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_EnumValueOptions_serialize(const google_protobuf_EnumValueOptions* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_EnumValueOptions_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_EnumValueOptions_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_EnumValueOptions_serialize_ex(const google_protobuf_EnumValueOptions* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_EnumValueOptions_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_EnumValueOptions_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_EnumValueOptions_has_deprecated(const google_protobuf_EnumValueOptions* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_EnumValueOptions_clear_deprecated(const google_protobuf_EnumValueOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE bool google_protobuf_EnumValueOptions_deprecated(const google_protobuf_EnumValueOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
}
UPB_INLINE bool google_protobuf_EnumValueOptions_has_uninterpreted_option(const google_protobuf_EnumValueOptions* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(4, 8));
}
+UPB_INLINE void google_protobuf_EnumValueOptions_clear_uninterpreted_option(const google_protobuf_EnumValueOptions* msg) {
+ _upb_array_detach(msg, UPB_SIZE(4, 8));
+}
UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_EnumValueOptions_uninterpreted_option(const google_protobuf_EnumValueOptions* msg, size_t* len) {
return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
}
@@ -4367,7 +4978,7 @@
return (google_protobuf_UninterpretedOption**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_EnumValueOptions_add_uninterpreted_option(google_protobuf_EnumValueOptions* msg, upb_Arena* arena) {
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msginit, arena);
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -4376,12 +4987,12 @@
/* google.protobuf.ServiceOptions */
UPB_INLINE google_protobuf_ServiceOptions* google_protobuf_ServiceOptions_new(upb_Arena* arena) {
- return (google_protobuf_ServiceOptions*)_upb_Message_New(&google_protobuf_ServiceOptions_msginit, arena);
+ return (google_protobuf_ServiceOptions*)_upb_Message_New(&google_protobuf_ServiceOptions_msg_init, arena);
}
UPB_INLINE google_protobuf_ServiceOptions* google_protobuf_ServiceOptions_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_ServiceOptions* ret = google_protobuf_ServiceOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_ServiceOptions_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_ServiceOptions_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4391,28 +5002,39 @@
int options, upb_Arena* arena) {
google_protobuf_ServiceOptions* ret = google_protobuf_ServiceOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_ServiceOptions_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_ServiceOptions_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_ServiceOptions_serialize(const google_protobuf_ServiceOptions* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_ServiceOptions_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_ServiceOptions_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_ServiceOptions_serialize_ex(const google_protobuf_ServiceOptions* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_ServiceOptions_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_ServiceOptions_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_ServiceOptions_has_deprecated(const google_protobuf_ServiceOptions* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_ServiceOptions_clear_deprecated(const google_protobuf_ServiceOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE bool google_protobuf_ServiceOptions_deprecated(const google_protobuf_ServiceOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
}
UPB_INLINE bool google_protobuf_ServiceOptions_has_uninterpreted_option(const google_protobuf_ServiceOptions* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(4, 8));
}
+UPB_INLINE void google_protobuf_ServiceOptions_clear_uninterpreted_option(const google_protobuf_ServiceOptions* msg) {
+ _upb_array_detach(msg, UPB_SIZE(4, 8));
+}
UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_ServiceOptions_uninterpreted_option(const google_protobuf_ServiceOptions* msg, size_t* len) {
return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
}
@@ -4428,7 +5050,7 @@
return (google_protobuf_UninterpretedOption**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_ServiceOptions_add_uninterpreted_option(google_protobuf_ServiceOptions* msg, upb_Arena* arena) {
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msginit, arena);
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -4437,12 +5059,12 @@
/* google.protobuf.MethodOptions */
UPB_INLINE google_protobuf_MethodOptions* google_protobuf_MethodOptions_new(upb_Arena* arena) {
- return (google_protobuf_MethodOptions*)_upb_Message_New(&google_protobuf_MethodOptions_msginit, arena);
+ return (google_protobuf_MethodOptions*)_upb_Message_New(&google_protobuf_MethodOptions_msg_init, arena);
}
UPB_INLINE google_protobuf_MethodOptions* google_protobuf_MethodOptions_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_MethodOptions* ret = google_protobuf_MethodOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_MethodOptions_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_MethodOptions_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4452,55 +5074,70 @@
int options, upb_Arena* arena) {
google_protobuf_MethodOptions* ret = google_protobuf_MethodOptions_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_MethodOptions_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_MethodOptions_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_MethodOptions_serialize(const google_protobuf_MethodOptions* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_MethodOptions_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_MethodOptions_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_MethodOptions_serialize_ex(const google_protobuf_MethodOptions* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_MethodOptions_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_MethodOptions_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_MethodOptions_has_deprecated(const google_protobuf_MethodOptions* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_MethodOptions_clear_deprecated(const google_protobuf_MethodOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE bool google_protobuf_MethodOptions_deprecated(const google_protobuf_MethodOptions* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool);
+ return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
}
UPB_INLINE bool google_protobuf_MethodOptions_has_idempotency_level(const google_protobuf_MethodOptions* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_MethodOptions_clear_idempotency_level(const google_protobuf_MethodOptions* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE int32_t google_protobuf_MethodOptions_idempotency_level(const google_protobuf_MethodOptions* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
}
UPB_INLINE bool google_protobuf_MethodOptions_has_uninterpreted_option(const google_protobuf_MethodOptions* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(12, 16));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(8, 8));
+}
+UPB_INLINE void google_protobuf_MethodOptions_clear_uninterpreted_option(const google_protobuf_MethodOptions* msg) {
+ _upb_array_detach(msg, UPB_SIZE(8, 8));
}
UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_MethodOptions_uninterpreted_option(const google_protobuf_MethodOptions* msg, size_t* len) {
- return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(12, 16), len);
+ return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(8, 8), len);
}
UPB_INLINE void google_protobuf_MethodOptions_set_deprecated(google_protobuf_MethodOptions *msg, bool value) {
_upb_sethas(msg, 1);
- *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
}
UPB_INLINE void google_protobuf_MethodOptions_set_idempotency_level(google_protobuf_MethodOptions *msg, int32_t value) {
_upb_sethas(msg, 2);
*UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = value;
}
UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_MethodOptions_mutable_uninterpreted_option(google_protobuf_MethodOptions* msg, size_t* len) {
- return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(12, 16), len);
+ return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(8, 8), len);
}
UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_MethodOptions_resize_uninterpreted_option(google_protobuf_MethodOptions* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_UninterpretedOption**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(12, 16), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_UninterpretedOption**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(8, 8), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_MethodOptions_add_uninterpreted_option(google_protobuf_MethodOptions* msg, upb_Arena* arena) {
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(12, 16), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 8), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
@@ -4508,12 +5145,12 @@
/* google.protobuf.UninterpretedOption */
UPB_INLINE google_protobuf_UninterpretedOption* google_protobuf_UninterpretedOption_new(upb_Arena* arena) {
- return (google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msginit, arena);
+ return (google_protobuf_UninterpretedOption*)_upb_Message_New(&google_protobuf_UninterpretedOption_msg_init, arena);
}
UPB_INLINE google_protobuf_UninterpretedOption* google_protobuf_UninterpretedOption_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_UninterpretedOption* ret = google_protobuf_UninterpretedOption_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_UninterpretedOption_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_UninterpretedOption_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4523,108 +5160,139 @@
int options, upb_Arena* arena) {
google_protobuf_UninterpretedOption* ret = google_protobuf_UninterpretedOption_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_UninterpretedOption_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_UninterpretedOption_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_UninterpretedOption_serialize(const google_protobuf_UninterpretedOption* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_UninterpretedOption_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_UninterpretedOption_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_UninterpretedOption_serialize_ex(const google_protobuf_UninterpretedOption* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_UninterpretedOption_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_UninterpretedOption_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_UninterpretedOption_has_name(const google_protobuf_UninterpretedOption* msg) {
- return _upb_has_submsg_nohasbit(msg, UPB_SIZE(56, 80));
+ return _upb_has_submsg_nohasbit(msg, UPB_SIZE(4, 8));
+}
+UPB_INLINE void google_protobuf_UninterpretedOption_clear_name(const google_protobuf_UninterpretedOption* msg) {
+ _upb_array_detach(msg, UPB_SIZE(4, 8));
}
UPB_INLINE const google_protobuf_UninterpretedOption_NamePart* const* google_protobuf_UninterpretedOption_name(const google_protobuf_UninterpretedOption* msg, size_t* len) {
- return (const google_protobuf_UninterpretedOption_NamePart* const*)_upb_array_accessor(msg, UPB_SIZE(56, 80), len);
+ return (const google_protobuf_UninterpretedOption_NamePart* const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
}
UPB_INLINE bool google_protobuf_UninterpretedOption_has_identifier_value(const google_protobuf_UninterpretedOption* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_UninterpretedOption_clear_identifier_value(const google_protobuf_UninterpretedOption* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 16), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_UninterpretedOption_identifier_value(const google_protobuf_UninterpretedOption* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), upb_StringView);
+ return *UPB_PTR_AT(msg, UPB_SIZE(8, 16), upb_StringView);
}
UPB_INLINE bool google_protobuf_UninterpretedOption_has_positive_int_value(const google_protobuf_UninterpretedOption* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_UninterpretedOption_clear_positive_int_value(const google_protobuf_UninterpretedOption* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(32, 64), uint64_t) = 0;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE uint64_t google_protobuf_UninterpretedOption_positive_int_value(const google_protobuf_UninterpretedOption* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t);
+ return *UPB_PTR_AT(msg, UPB_SIZE(32, 64), uint64_t);
}
UPB_INLINE bool google_protobuf_UninterpretedOption_has_negative_int_value(const google_protobuf_UninterpretedOption* msg) {
return _upb_hasbit(msg, 3);
}
+UPB_INLINE void google_protobuf_UninterpretedOption_clear_negative_int_value(const google_protobuf_UninterpretedOption* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(40, 72), int64_t) = 0;
+ _upb_clearhas(msg, 3);
+}
UPB_INLINE int64_t google_protobuf_UninterpretedOption_negative_int_value(const google_protobuf_UninterpretedOption* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int64_t);
+ return *UPB_PTR_AT(msg, UPB_SIZE(40, 72), int64_t);
}
UPB_INLINE bool google_protobuf_UninterpretedOption_has_double_value(const google_protobuf_UninterpretedOption* msg) {
return _upb_hasbit(msg, 4);
}
+UPB_INLINE void google_protobuf_UninterpretedOption_clear_double_value(const google_protobuf_UninterpretedOption* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(48, 80), double) = 0;
+ _upb_clearhas(msg, 4);
+}
UPB_INLINE double google_protobuf_UninterpretedOption_double_value(const google_protobuf_UninterpretedOption* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), double);
+ return *UPB_PTR_AT(msg, UPB_SIZE(48, 80), double);
}
UPB_INLINE bool google_protobuf_UninterpretedOption_has_string_value(const google_protobuf_UninterpretedOption* msg) {
return _upb_hasbit(msg, 5);
}
+UPB_INLINE void google_protobuf_UninterpretedOption_clear_string_value(const google_protobuf_UninterpretedOption* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 32), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 5);
+}
UPB_INLINE upb_StringView google_protobuf_UninterpretedOption_string_value(const google_protobuf_UninterpretedOption* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(40, 48), upb_StringView);
+ return *UPB_PTR_AT(msg, UPB_SIZE(16, 32), upb_StringView);
}
UPB_INLINE bool google_protobuf_UninterpretedOption_has_aggregate_value(const google_protobuf_UninterpretedOption* msg) {
return _upb_hasbit(msg, 6);
}
+UPB_INLINE void google_protobuf_UninterpretedOption_clear_aggregate_value(const google_protobuf_UninterpretedOption* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(24, 48), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 6);
+}
UPB_INLINE upb_StringView google_protobuf_UninterpretedOption_aggregate_value(const google_protobuf_UninterpretedOption* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(48, 64), upb_StringView);
+ return *UPB_PTR_AT(msg, UPB_SIZE(24, 48), upb_StringView);
}
UPB_INLINE google_protobuf_UninterpretedOption_NamePart** google_protobuf_UninterpretedOption_mutable_name(google_protobuf_UninterpretedOption* msg, size_t* len) {
- return (google_protobuf_UninterpretedOption_NamePart**)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 80), len);
+ return (google_protobuf_UninterpretedOption_NamePart**)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
}
UPB_INLINE google_protobuf_UninterpretedOption_NamePart** google_protobuf_UninterpretedOption_resize_name(google_protobuf_UninterpretedOption* msg, size_t len, upb_Arena* arena) {
- return (google_protobuf_UninterpretedOption_NamePart**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(56, 80), len, UPB_SIZE(2, 3), arena);
+ return (google_protobuf_UninterpretedOption_NamePart**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_UninterpretedOption_NamePart* google_protobuf_UninterpretedOption_add_name(google_protobuf_UninterpretedOption* msg, upb_Arena* arena) {
- struct google_protobuf_UninterpretedOption_NamePart* sub = (struct google_protobuf_UninterpretedOption_NamePart*)_upb_Message_New(&google_protobuf_UninterpretedOption_NamePart_msginit, arena);
- bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(56, 80), UPB_SIZE(2, 3), &sub, arena);
+ struct google_protobuf_UninterpretedOption_NamePart* sub = (struct google_protobuf_UninterpretedOption_NamePart*)_upb_Message_New(&google_protobuf_UninterpretedOption_NamePart_msg_init, arena);
+ bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
}
UPB_INLINE void google_protobuf_UninterpretedOption_set_identifier_value(google_protobuf_UninterpretedOption *msg, upb_StringView value) {
_upb_sethas(msg, 1);
- *UPB_PTR_AT(msg, UPB_SIZE(32, 32), upb_StringView) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 16), upb_StringView) = value;
}
UPB_INLINE void google_protobuf_UninterpretedOption_set_positive_int_value(google_protobuf_UninterpretedOption *msg, uint64_t value) {
_upb_sethas(msg, 2);
- *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(32, 64), uint64_t) = value;
}
UPB_INLINE void google_protobuf_UninterpretedOption_set_negative_int_value(google_protobuf_UninterpretedOption *msg, int64_t value) {
_upb_sethas(msg, 3);
- *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int64_t) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(40, 72), int64_t) = value;
}
UPB_INLINE void google_protobuf_UninterpretedOption_set_double_value(google_protobuf_UninterpretedOption *msg, double value) {
_upb_sethas(msg, 4);
- *UPB_PTR_AT(msg, UPB_SIZE(24, 24), double) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(48, 80), double) = value;
}
UPB_INLINE void google_protobuf_UninterpretedOption_set_string_value(google_protobuf_UninterpretedOption *msg, upb_StringView value) {
_upb_sethas(msg, 5);
- *UPB_PTR_AT(msg, UPB_SIZE(40, 48), upb_StringView) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 32), upb_StringView) = value;
}
UPB_INLINE void google_protobuf_UninterpretedOption_set_aggregate_value(google_protobuf_UninterpretedOption *msg, upb_StringView value) {
_upb_sethas(msg, 6);
- *UPB_PTR_AT(msg, UPB_SIZE(48, 64), upb_StringView) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(24, 48), upb_StringView) = value;
}
/* google.protobuf.UninterpretedOption.NamePart */
UPB_INLINE google_protobuf_UninterpretedOption_NamePart* google_protobuf_UninterpretedOption_NamePart_new(upb_Arena* arena) {
- return (google_protobuf_UninterpretedOption_NamePart*)_upb_Message_New(&google_protobuf_UninterpretedOption_NamePart_msginit, arena);
+ return (google_protobuf_UninterpretedOption_NamePart*)_upb_Message_New(&google_protobuf_UninterpretedOption_NamePart_msg_init, arena);
}
UPB_INLINE google_protobuf_UninterpretedOption_NamePart* google_protobuf_UninterpretedOption_NamePart_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_UninterpretedOption_NamePart* ret = google_protobuf_UninterpretedOption_NamePart_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_UninterpretedOption_NamePart_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_UninterpretedOption_NamePart_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4634,28 +5302,40 @@
int options, upb_Arena* arena) {
google_protobuf_UninterpretedOption_NamePart* ret = google_protobuf_UninterpretedOption_NamePart_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_UninterpretedOption_NamePart_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_UninterpretedOption_NamePart_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_UninterpretedOption_NamePart_serialize(const google_protobuf_UninterpretedOption_NamePart* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_UninterpretedOption_NamePart_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_UninterpretedOption_NamePart_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_UninterpretedOption_NamePart_serialize_ex(const google_protobuf_UninterpretedOption_NamePart* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_UninterpretedOption_NamePart_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_UninterpretedOption_NamePart_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_UninterpretedOption_NamePart_has_name_part(const google_protobuf_UninterpretedOption_NamePart* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_UninterpretedOption_NamePart_clear_name_part(const google_protobuf_UninterpretedOption_NamePart* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_UninterpretedOption_NamePart_name_part(const google_protobuf_UninterpretedOption_NamePart* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView);
}
UPB_INLINE bool google_protobuf_UninterpretedOption_NamePart_has_is_extension(const google_protobuf_UninterpretedOption_NamePart* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_UninterpretedOption_NamePart_clear_is_extension(const google_protobuf_UninterpretedOption_NamePart* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE bool google_protobuf_UninterpretedOption_NamePart_is_extension(const google_protobuf_UninterpretedOption_NamePart* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
}
@@ -4672,12 +5352,12 @@
/* google.protobuf.SourceCodeInfo */
UPB_INLINE google_protobuf_SourceCodeInfo* google_protobuf_SourceCodeInfo_new(upb_Arena* arena) {
- return (google_protobuf_SourceCodeInfo*)_upb_Message_New(&google_protobuf_SourceCodeInfo_msginit, arena);
+ return (google_protobuf_SourceCodeInfo*)_upb_Message_New(&google_protobuf_SourceCodeInfo_msg_init, arena);
}
UPB_INLINE google_protobuf_SourceCodeInfo* google_protobuf_SourceCodeInfo_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_SourceCodeInfo* ret = google_protobuf_SourceCodeInfo_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_SourceCodeInfo_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_SourceCodeInfo_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4687,22 +5367,29 @@
int options, upb_Arena* arena) {
google_protobuf_SourceCodeInfo* ret = google_protobuf_SourceCodeInfo_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_SourceCodeInfo_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_SourceCodeInfo_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_SourceCodeInfo_serialize(const google_protobuf_SourceCodeInfo* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_SourceCodeInfo_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_SourceCodeInfo_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_SourceCodeInfo_serialize_ex(const google_protobuf_SourceCodeInfo* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_SourceCodeInfo_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_SourceCodeInfo_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_SourceCodeInfo_has_location(const google_protobuf_SourceCodeInfo* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0));
}
+UPB_INLINE void google_protobuf_SourceCodeInfo_clear_location(const google_protobuf_SourceCodeInfo* msg) {
+ _upb_array_detach(msg, UPB_SIZE(0, 0));
+}
UPB_INLINE const google_protobuf_SourceCodeInfo_Location* const* google_protobuf_SourceCodeInfo_location(const google_protobuf_SourceCodeInfo* msg, size_t* len) {
return (const google_protobuf_SourceCodeInfo_Location* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len);
}
@@ -4714,7 +5401,7 @@
return (google_protobuf_SourceCodeInfo_Location**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(0, 0), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_SourceCodeInfo_Location* google_protobuf_SourceCodeInfo_add_location(google_protobuf_SourceCodeInfo* msg, upb_Arena* arena) {
- struct google_protobuf_SourceCodeInfo_Location* sub = (struct google_protobuf_SourceCodeInfo_Location*)_upb_Message_New(&google_protobuf_SourceCodeInfo_Location_msginit, arena);
+ struct google_protobuf_SourceCodeInfo_Location* sub = (struct google_protobuf_SourceCodeInfo_Location*)_upb_Message_New(&google_protobuf_SourceCodeInfo_Location_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(0, 0), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -4723,12 +5410,12 @@
/* google.protobuf.SourceCodeInfo.Location */
UPB_INLINE google_protobuf_SourceCodeInfo_Location* google_protobuf_SourceCodeInfo_Location_new(upb_Arena* arena) {
- return (google_protobuf_SourceCodeInfo_Location*)_upb_Message_New(&google_protobuf_SourceCodeInfo_Location_msginit, arena);
+ return (google_protobuf_SourceCodeInfo_Location*)_upb_Message_New(&google_protobuf_SourceCodeInfo_Location_msg_init, arena);
}
UPB_INLINE google_protobuf_SourceCodeInfo_Location* google_protobuf_SourceCodeInfo_Location_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_SourceCodeInfo_Location* ret = google_protobuf_SourceCodeInfo_Location_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_SourceCodeInfo_Location_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_SourceCodeInfo_Location_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4738,66 +5425,87 @@
int options, upb_Arena* arena) {
google_protobuf_SourceCodeInfo_Location* ret = google_protobuf_SourceCodeInfo_Location_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_SourceCodeInfo_Location_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_SourceCodeInfo_Location_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_SourceCodeInfo_Location_serialize(const google_protobuf_SourceCodeInfo_Location* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_SourceCodeInfo_Location_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_SourceCodeInfo_Location_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_SourceCodeInfo_Location_serialize_ex(const google_protobuf_SourceCodeInfo_Location* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_SourceCodeInfo_Location_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_SourceCodeInfo_Location_msg_init, options, arena, &ptr, len);
+ return ptr;
+}
+UPB_INLINE void google_protobuf_SourceCodeInfo_Location_clear_path(const google_protobuf_SourceCodeInfo_Location* msg) {
+ _upb_array_detach(msg, UPB_SIZE(4, 8));
}
UPB_INLINE int32_t const* google_protobuf_SourceCodeInfo_Location_path(const google_protobuf_SourceCodeInfo_Location* msg, size_t* len) {
- return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(20, 40), len);
+ return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
+}
+UPB_INLINE void google_protobuf_SourceCodeInfo_Location_clear_span(const google_protobuf_SourceCodeInfo_Location* msg) {
+ _upb_array_detach(msg, UPB_SIZE(8, 16));
}
UPB_INLINE int32_t const* google_protobuf_SourceCodeInfo_Location_span(const google_protobuf_SourceCodeInfo_Location* msg, size_t* len) {
- return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len);
+ return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(8, 16), len);
}
UPB_INLINE bool google_protobuf_SourceCodeInfo_Location_has_leading_comments(const google_protobuf_SourceCodeInfo_Location* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_SourceCodeInfo_Location_clear_leading_comments(const google_protobuf_SourceCodeInfo_Location* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_SourceCodeInfo_Location_leading_comments(const google_protobuf_SourceCodeInfo_Location* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView);
+ return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_StringView);
}
UPB_INLINE bool google_protobuf_SourceCodeInfo_Location_has_trailing_comments(const google_protobuf_SourceCodeInfo_Location* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_SourceCodeInfo_Location_clear_trailing_comments(const google_protobuf_SourceCodeInfo_Location* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE upb_StringView google_protobuf_SourceCodeInfo_Location_trailing_comments(const google_protobuf_SourceCodeInfo_Location* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_StringView);
+ return *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_StringView);
+}
+UPB_INLINE void google_protobuf_SourceCodeInfo_Location_clear_leading_detached_comments(const google_protobuf_SourceCodeInfo_Location* msg) {
+ _upb_array_detach(msg, UPB_SIZE(28, 56));
}
UPB_INLINE upb_StringView const* google_protobuf_SourceCodeInfo_Location_leading_detached_comments(const google_protobuf_SourceCodeInfo_Location* msg, size_t* len) {
return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(28, 56), len);
}
UPB_INLINE int32_t* google_protobuf_SourceCodeInfo_Location_mutable_path(google_protobuf_SourceCodeInfo_Location* msg, size_t* len) {
- return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(20, 40), len);
+ return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
}
UPB_INLINE int32_t* google_protobuf_SourceCodeInfo_Location_resize_path(google_protobuf_SourceCodeInfo_Location* msg, size_t len, upb_Arena* arena) {
- return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(20, 40), len, 2, arena);
+ return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, 2, arena);
}
UPB_INLINE bool google_protobuf_SourceCodeInfo_Location_add_path(google_protobuf_SourceCodeInfo_Location* msg, int32_t val, upb_Arena* arena) {
- return _upb_Array_Append_accessor2(msg, UPB_SIZE(20, 40), 2, &val, arena);
+ return _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), 2, &val, arena);
}
UPB_INLINE int32_t* google_protobuf_SourceCodeInfo_Location_mutable_span(google_protobuf_SourceCodeInfo_Location* msg, size_t* len) {
- return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 48), len);
+ return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(8, 16), len);
}
UPB_INLINE int32_t* google_protobuf_SourceCodeInfo_Location_resize_span(google_protobuf_SourceCodeInfo_Location* msg, size_t len, upb_Arena* arena) {
- return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(24, 48), len, 2, arena);
+ return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(8, 16), len, 2, arena);
}
UPB_INLINE bool google_protobuf_SourceCodeInfo_Location_add_span(google_protobuf_SourceCodeInfo_Location* msg, int32_t val, upb_Arena* arena) {
- return _upb_Array_Append_accessor2(msg, UPB_SIZE(24, 48), 2, &val, arena);
+ return _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 16), 2, &val, arena);
}
UPB_INLINE void google_protobuf_SourceCodeInfo_Location_set_leading_comments(google_protobuf_SourceCodeInfo_Location *msg, upb_StringView value) {
_upb_sethas(msg, 1);
- *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_StringView) = value;
}
UPB_INLINE void google_protobuf_SourceCodeInfo_Location_set_trailing_comments(google_protobuf_SourceCodeInfo_Location *msg, upb_StringView value) {
_upb_sethas(msg, 2);
- *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_StringView) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_StringView) = value;
}
UPB_INLINE upb_StringView* google_protobuf_SourceCodeInfo_Location_mutable_leading_detached_comments(google_protobuf_SourceCodeInfo_Location* msg, size_t* len) {
return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 56), len);
@@ -4812,12 +5520,12 @@
/* google.protobuf.GeneratedCodeInfo */
UPB_INLINE google_protobuf_GeneratedCodeInfo* google_protobuf_GeneratedCodeInfo_new(upb_Arena* arena) {
- return (google_protobuf_GeneratedCodeInfo*)_upb_Message_New(&google_protobuf_GeneratedCodeInfo_msginit, arena);
+ return (google_protobuf_GeneratedCodeInfo*)_upb_Message_New(&google_protobuf_GeneratedCodeInfo_msg_init, arena);
}
UPB_INLINE google_protobuf_GeneratedCodeInfo* google_protobuf_GeneratedCodeInfo_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_GeneratedCodeInfo* ret = google_protobuf_GeneratedCodeInfo_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_GeneratedCodeInfo_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_GeneratedCodeInfo_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4827,22 +5535,29 @@
int options, upb_Arena* arena) {
google_protobuf_GeneratedCodeInfo* ret = google_protobuf_GeneratedCodeInfo_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_GeneratedCodeInfo_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_GeneratedCodeInfo_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_GeneratedCodeInfo_serialize(const google_protobuf_GeneratedCodeInfo* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_GeneratedCodeInfo_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_GeneratedCodeInfo_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_GeneratedCodeInfo_serialize_ex(const google_protobuf_GeneratedCodeInfo* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_GeneratedCodeInfo_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_GeneratedCodeInfo_msg_init, options, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE bool google_protobuf_GeneratedCodeInfo_has_annotation(const google_protobuf_GeneratedCodeInfo* msg) {
return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0));
}
+UPB_INLINE void google_protobuf_GeneratedCodeInfo_clear_annotation(const google_protobuf_GeneratedCodeInfo* msg) {
+ _upb_array_detach(msg, UPB_SIZE(0, 0));
+}
UPB_INLINE const google_protobuf_GeneratedCodeInfo_Annotation* const* google_protobuf_GeneratedCodeInfo_annotation(const google_protobuf_GeneratedCodeInfo* msg, size_t* len) {
return (const google_protobuf_GeneratedCodeInfo_Annotation* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len);
}
@@ -4854,7 +5569,7 @@
return (google_protobuf_GeneratedCodeInfo_Annotation**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(0, 0), len, UPB_SIZE(2, 3), arena);
}
UPB_INLINE struct google_protobuf_GeneratedCodeInfo_Annotation* google_protobuf_GeneratedCodeInfo_add_annotation(google_protobuf_GeneratedCodeInfo* msg, upb_Arena* arena) {
- struct google_protobuf_GeneratedCodeInfo_Annotation* sub = (struct google_protobuf_GeneratedCodeInfo_Annotation*)_upb_Message_New(&google_protobuf_GeneratedCodeInfo_Annotation_msginit, arena);
+ struct google_protobuf_GeneratedCodeInfo_Annotation* sub = (struct google_protobuf_GeneratedCodeInfo_Annotation*)_upb_Message_New(&google_protobuf_GeneratedCodeInfo_Annotation_msg_init, arena);
bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(0, 0), UPB_SIZE(2, 3), &sub, arena);
if (!ok) return NULL;
return sub;
@@ -4863,12 +5578,12 @@
/* google.protobuf.GeneratedCodeInfo.Annotation */
UPB_INLINE google_protobuf_GeneratedCodeInfo_Annotation* google_protobuf_GeneratedCodeInfo_Annotation_new(upb_Arena* arena) {
- return (google_protobuf_GeneratedCodeInfo_Annotation*)_upb_Message_New(&google_protobuf_GeneratedCodeInfo_Annotation_msginit, arena);
+ return (google_protobuf_GeneratedCodeInfo_Annotation*)_upb_Message_New(&google_protobuf_GeneratedCodeInfo_Annotation_msg_init, arena);
}
UPB_INLINE google_protobuf_GeneratedCodeInfo_Annotation* google_protobuf_GeneratedCodeInfo_Annotation_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_GeneratedCodeInfo_Annotation* ret = google_protobuf_GeneratedCodeInfo_Annotation_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_GeneratedCodeInfo_Annotation_msginit, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+ if (upb_Decode(buf, size, ret, &google_protobuf_GeneratedCodeInfo_Annotation_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
@@ -4878,53 +5593,82 @@
int options, upb_Arena* arena) {
google_protobuf_GeneratedCodeInfo_Annotation* ret = google_protobuf_GeneratedCodeInfo_Annotation_new(arena);
if (!ret) return NULL;
- if (upb_Decode(buf, size, ret, &google_protobuf_GeneratedCodeInfo_Annotation_msginit, extreg, options, arena) !=
+ if (upb_Decode(buf, size, ret, &google_protobuf_GeneratedCodeInfo_Annotation_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_GeneratedCodeInfo_Annotation_serialize(const google_protobuf_GeneratedCodeInfo_Annotation* msg, upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_GeneratedCodeInfo_Annotation_msginit, 0, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_GeneratedCodeInfo_Annotation_msg_init, 0, arena, &ptr, len);
+ return ptr;
}
UPB_INLINE char* google_protobuf_GeneratedCodeInfo_Annotation_serialize_ex(const google_protobuf_GeneratedCodeInfo_Annotation* msg, int options,
upb_Arena* arena, size_t* len) {
- return upb_Encode(msg, &google_protobuf_GeneratedCodeInfo_Annotation_msginit, options, arena, len);
+ char* ptr;
+ (void)upb_Encode(msg, &google_protobuf_GeneratedCodeInfo_Annotation_msg_init, options, arena, &ptr, len);
+ return ptr;
+}
+UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_clear_path(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
+ _upb_array_detach(msg, UPB_SIZE(16, 16));
}
UPB_INLINE int32_t const* google_protobuf_GeneratedCodeInfo_Annotation_path(const google_protobuf_GeneratedCodeInfo_Annotation* msg, size_t* len) {
- return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(20, 32), len);
+ return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(16, 16), len);
}
UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_has_source_file(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
return _upb_hasbit(msg, 1);
}
+UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_clear_source_file(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(20, 24), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+ _upb_clearhas(msg, 1);
+}
UPB_INLINE upb_StringView google_protobuf_GeneratedCodeInfo_Annotation_source_file(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
- return *UPB_PTR_AT(msg, UPB_SIZE(12, 16), upb_StringView);
+ return *UPB_PTR_AT(msg, UPB_SIZE(20, 24), upb_StringView);
}
UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_has_begin(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
return _upb_hasbit(msg, 2);
}
+UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_clear_begin(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+ _upb_clearhas(msg, 2);
+}
UPB_INLINE int32_t google_protobuf_GeneratedCodeInfo_Annotation_begin(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
}
UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_has_end(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
return _upb_hasbit(msg, 3);
}
+UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_clear_end(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = 0;
+ _upb_clearhas(msg, 3);
+}
UPB_INLINE int32_t google_protobuf_GeneratedCodeInfo_Annotation_end(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t);
}
+UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_has_semantic(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
+ return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_clear_semantic(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t) = 0;
+ _upb_clearhas(msg, 4);
+}
+UPB_INLINE int32_t google_protobuf_GeneratedCodeInfo_Annotation_semantic(const google_protobuf_GeneratedCodeInfo_Annotation* msg) {
+ return *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t);
+}
UPB_INLINE int32_t* google_protobuf_GeneratedCodeInfo_Annotation_mutable_path(google_protobuf_GeneratedCodeInfo_Annotation* msg, size_t* len) {
- return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(20, 32), len);
+ return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(16, 16), len);
}
UPB_INLINE int32_t* google_protobuf_GeneratedCodeInfo_Annotation_resize_path(google_protobuf_GeneratedCodeInfo_Annotation* msg, size_t len, upb_Arena* arena) {
- return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(20, 32), len, 2, arena);
+ return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(16, 16), len, 2, arena);
}
UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_add_path(google_protobuf_GeneratedCodeInfo_Annotation* msg, int32_t val, upb_Arena* arena) {
- return _upb_Array_Append_accessor2(msg, UPB_SIZE(20, 32), 2, &val, arena);
+ return _upb_Array_Append_accessor2(msg, UPB_SIZE(16, 16), 2, &val, arena);
}
UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_set_source_file(google_protobuf_GeneratedCodeInfo_Annotation *msg, upb_StringView value) {
_upb_sethas(msg, 1);
- *UPB_PTR_AT(msg, UPB_SIZE(12, 16), upb_StringView) = value;
+ *UPB_PTR_AT(msg, UPB_SIZE(20, 24), upb_StringView) = value;
}
UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_set_begin(google_protobuf_GeneratedCodeInfo_Annotation *msg, int32_t value) {
_upb_sethas(msg, 2);
@@ -4934,6 +5678,10 @@
_upb_sethas(msg, 3);
*UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
}
+UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_set_semantic(google_protobuf_GeneratedCodeInfo_Annotation *msg, int32_t value) {
+ _upb_sethas(msg, 4);
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t) = value;
+}
extern const upb_MiniTable_File google_protobuf_descriptor_proto_upb_file_layout;
@@ -4948,206 +5696,775 @@
#endif /* GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H_ */
-/** upb/def.h ************************************************************/
-#ifndef UPB_DEF_H_
-#define UPB_DEF_H_
+/*
+ * Internal implementation details of the decoder that are shared between
+ * decode.c and decode_fast.c.
+ */
+
+#ifndef UPB_INTERNAL_DECODE_H_
+#define UPB_INTERNAL_DECODE_H_
-/* Must be last. */
+#ifndef UPB_INTERNAL_ARENA_H_
+#define UPB_INTERNAL_ARENA_H_
+
+
+// Must be last.
#ifdef __cplusplus
extern "C" {
-#endif /* __cplusplus */
+#endif
-struct upb_EnumDef;
-typedef struct upb_EnumDef upb_EnumDef;
-struct upb_EnumValueDef;
-typedef struct upb_EnumValueDef upb_EnumValueDef;
-struct upb_ExtensionRange;
-typedef struct upb_ExtensionRange upb_ExtensionRange;
-struct upb_FieldDef;
-typedef struct upb_FieldDef upb_FieldDef;
-struct upb_FileDef;
-typedef struct upb_FileDef upb_FileDef;
-struct upb_MethodDef;
-typedef struct upb_MethodDef upb_MethodDef;
-struct upb_MessageDef;
-typedef struct upb_MessageDef upb_MessageDef;
-struct upb_OneofDef;
-typedef struct upb_OneofDef upb_OneofDef;
-struct upb_ServiceDef;
-typedef struct upb_ServiceDef upb_ServiceDef;
-struct upb_streamdef;
-typedef struct upb_streamdef upb_streamdef;
-struct upb_DefPool;
-typedef struct upb_DefPool upb_DefPool;
+typedef struct mem_block mem_block;
+
+struct upb_Arena {
+ _upb_ArenaHead head;
+ /* Stores cleanup metadata for this arena.
+ * - a pointer to the current cleanup counter.
+ * - a boolean indicating if there is an unowned initial block. */
+ uintptr_t cleanup_metadata;
+
+ /* Allocator to allocate arena blocks. We are responsible for freeing these
+ * when we are destroyed. */
+ upb_alloc* block_alloc;
+ uint32_t last_size;
+
+ /* When multiple arenas are fused together, each arena points to a parent
+ * arena (root points to itself). The root tracks how many live arenas
+ * reference it. */
+ uint32_t refcount; /* Only used when a->parent == a */
+ struct upb_Arena* parent;
+
+ /* Linked list of blocks to free/cleanup. */
+ mem_block *freelist, *freelist_tail;
+};
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_INTERNAL_ARENA_H_ */
+
+#include "third_party/utf8_range/utf8_range.h"
+
+// Must be last.
+
+#define DECODE_NOGROUP (uint32_t) - 1
+
+typedef struct upb_Decoder {
+ const char* end; /* Can read up to 16 bytes slop beyond this. */
+ const char* limit_ptr; /* = end + UPB_MIN(limit, 0) */
+ upb_Message* unknown_msg; /* Used for preserving unknown data. */
+ const char* unknown; /* Start of unknown data, preserve at buffer flip. */
+ const upb_ExtensionRegistry*
+ extreg; /* For looking up extensions during the parse. */
+ int limit; /* Submessage limit relative to end. */
+ int depth; /* Tracks recursion depth to bound stack usage. */
+ uint32_t end_group; /* field number of END_GROUP tag, else DECODE_NOGROUP */
+ uint16_t options;
+ bool missing_required;
+ char patch[32];
+ upb_Arena arena;
+ jmp_buf err;
+
+#ifndef NDEBUG
+ const char* debug_tagstart;
+ const char* debug_valstart;
+#endif
+} upb_Decoder;
+
+/* Error function that will abort decoding with longjmp(). We can't declare this
+ * UPB_NORETURN, even though it is appropriate, because if we do then compilers
+ * will "helpfully" refuse to tailcall to it
+ * (see: https://stackoverflow.com/a/55657013), which will defeat a major goal
+ * of our optimizations. That is also why we must declare it in a separate file,
+ * otherwise the compiler will see that it calls longjmp() and deduce that it is
+ * noreturn. */
+const char* _upb_FastDecoder_ErrorJmp(upb_Decoder* d, int status);
+
+extern const uint8_t upb_utf8_offsets[];
+
+UPB_INLINE
+bool _upb_Decoder_VerifyUtf8Inline(const char* ptr, int len) {
+ const char* end = ptr + len;
+
+ // Check 8 bytes at a time for any non-ASCII char.
+ while (end - ptr >= 8) {
+ uint64_t data;
+ memcpy(&data, ptr, 8);
+ if (data & 0x8080808080808080) goto non_ascii;
+ ptr += 8;
+ }
+
+ // Check one byte at a time for non-ASCII.
+ while (ptr < end) {
+ if (*ptr & 0x80) goto non_ascii;
+ ptr++;
+ }
+
+ return true;
+
+non_ascii:
+ return utf8_range2((const unsigned char*)ptr, end - ptr) == 0;
+}
+
+const char* _upb_Decoder_CheckRequired(upb_Decoder* d, const char* ptr,
+ const upb_Message* msg,
+ const upb_MiniTable* l);
+
+/* x86-64 pointers always have the high 16 bits matching. So we can shift
+ * left 8 and right 8 without loss of information. */
+UPB_INLINE intptr_t decode_totable(const upb_MiniTable* tablep) {
+ return ((intptr_t)tablep << 8) | tablep->table_mask;
+}
+
+UPB_INLINE const upb_MiniTable* decode_totablep(intptr_t table) {
+ return (const upb_MiniTable*)(table >> 8);
+}
+
+UPB_INLINE
+const char* _upb_Decoder_IsDoneFallbackInline(upb_Decoder* d, const char* ptr,
+ int overrun, int* status) {
+ if (overrun < d->limit) {
+ /* Need to copy remaining data into patch buffer. */
+ UPB_ASSERT(overrun < 16);
+ if (d->unknown) {
+ if (!_upb_Message_AddUnknown(d->unknown_msg, d->unknown, ptr - d->unknown,
+ &d->arena)) {
+ *status = kUpb_DecodeStatus_OutOfMemory;
+ return NULL;
+ }
+ d->unknown = &d->patch[0] + overrun;
+ }
+ memset(d->patch + 16, 0, 16);
+ memcpy(d->patch, d->end, 16);
+ ptr = &d->patch[0] + overrun;
+ d->end = &d->patch[16];
+ d->limit -= 16;
+ d->limit_ptr = d->end + d->limit;
+ d->options &= ~kUpb_DecodeOption_AliasString;
+ UPB_ASSERT(ptr < d->limit_ptr);
+ return ptr;
+ } else {
+ *status = kUpb_DecodeStatus_Malformed;
+ return NULL;
+ }
+}
+
+const char* _upb_Decoder_IsDoneFallback(upb_Decoder* d, const char* ptr,
+ int overrun);
+
+UPB_INLINE
+bool _upb_Decoder_IsDone(upb_Decoder* d, const char** ptr) {
+ int overrun = *ptr - d->end;
+ if (UPB_LIKELY(*ptr < d->limit_ptr)) {
+ return false;
+ } else if (UPB_LIKELY(overrun == d->limit)) {
+ return true;
+ } else {
+ *ptr = _upb_Decoder_IsDoneFallback(d, *ptr, overrun);
+ return false;
+ }
+}
+
+#if UPB_FASTTABLE
+UPB_INLINE
+const char* _upb_FastDecoder_TagDispatch(upb_Decoder* d, const char* ptr,
+ upb_Message* msg, intptr_t table,
+ uint64_t hasbits, uint64_t tag) {
+ const upb_MiniTable* table_p = decode_totablep(table);
+ uint8_t mask = table;
+ uint64_t data;
+ size_t idx = tag & mask;
+ UPB_ASSUME((idx & 7) == 0);
+ idx >>= 3;
+ data = table_p->fasttable[idx].field_data ^ tag;
+ UPB_MUSTTAIL return table_p->fasttable[idx].field_parser(d, ptr, msg, table,
+ hasbits, data);
+}
+#endif
+
+UPB_INLINE uint32_t _upb_FastDecoder_LoadTag(const char* ptr) {
+ uint16_t tag;
+ memcpy(&tag, ptr, 2);
+ return tag;
+}
+
+UPB_INLINE void _upb_Decoder_CheckLimit(upb_Decoder* d) {
+ UPB_ASSERT(d->limit_ptr == d->end + UPB_MIN(0, d->limit));
+}
+
+UPB_INLINE int _upb_Decoder_PushLimit(upb_Decoder* d, const char* ptr,
+ int size) {
+ int limit = size + (int)(ptr - d->end);
+ int delta = d->limit - limit;
+ _upb_Decoder_CheckLimit(d);
+ d->limit = limit;
+ d->limit_ptr = d->end + UPB_MIN(0, limit);
+ _upb_Decoder_CheckLimit(d);
+ return delta;
+}
+
+UPB_INLINE void _upb_Decoder_PopLimit(upb_Decoder* d, const char* ptr,
+ int saved_delta) {
+ UPB_ASSERT(ptr - d->end == d->limit);
+ _upb_Decoder_CheckLimit(d);
+ d->limit += saved_delta;
+ d->limit_ptr = d->end + UPB_MIN(0, d->limit);
+ _upb_Decoder_CheckLimit(d);
+}
+
+
+#endif /* UPB_INTERNAL_DECODE_H_ */
+
+#ifndef UPB_JSON_DECODE_H_
+#define UPB_JSON_DECODE_H_
+
+
+#ifndef UPB_REFLECTION_DEF_H_
+#define UPB_REFLECTION_DEF_H_
+
+
+// IWYU pragma: private, include "third_party/upb/upb/reflection/def.h"
+
+#ifndef UPB_REFLECTION_DEF_POOL_H_
+#define UPB_REFLECTION_DEF_POOL_H_
+
+
+// IWYU pragma: private, include "third_party/upb/upb/reflection/def.h"
+
+// Declarations common to all public def types.
+
+#ifndef UPB_REFLECTION_COMMON_H_
+#define UPB_REFLECTION_COMMON_H_
+
typedef enum { kUpb_Syntax_Proto2 = 2, kUpb_Syntax_Proto3 = 3 } upb_Syntax;
-/* All the different kind of well known type messages. For simplicity of check,
- * number wrappers and string wrappers are grouped together. Make sure the
- * order and merber of these groups are not changed.
- */
+// Forward declarations for circular references.
+typedef struct upb_DefPool upb_DefPool;
+typedef struct upb_EnumDef upb_EnumDef;
+typedef struct upb_EnumValueDef upb_EnumValueDef;
+typedef struct upb_ExtensionRange upb_ExtensionRange;
+typedef struct upb_FieldDef upb_FieldDef;
+typedef struct upb_FileDef upb_FileDef;
+typedef struct upb_MessageDef upb_MessageDef;
+typedef struct upb_MethodDef upb_MethodDef;
+typedef struct upb_OneofDef upb_OneofDef;
+typedef struct upb_ServiceDef upb_ServiceDef;
+
+// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
+
+typedef struct upb_DefBuilder upb_DefBuilder;
+
+#endif /* UPB_REFLECTION_COMMON_H_ */
+
+#ifndef UPB_REFLECTION_DEF_TYPE_H_
+#define UPB_REFLECTION_DEF_TYPE_H_
+
+
+// Must be last.
+
+// Inside a symtab we store tagged pointers to specific def types.
+typedef enum {
+ UPB_DEFTYPE_MASK = 7,
+
+ // Only inside symtab table.
+ UPB_DEFTYPE_EXT = 0,
+ UPB_DEFTYPE_MSG = 1,
+ UPB_DEFTYPE_ENUM = 2,
+ UPB_DEFTYPE_ENUMVAL = 3,
+ UPB_DEFTYPE_SERVICE = 4,
+
+ // Only inside message table.
+ UPB_DEFTYPE_FIELD = 0,
+ UPB_DEFTYPE_ONEOF = 1,
+ UPB_DEFTYPE_FIELD_JSONNAME = 2,
+} upb_deftype_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Our 3-bit pointer tagging requires all pointers to be multiples of 8.
+// The arena will always yield 8-byte-aligned addresses, however we put
+// the defs into arrays. For each element in the array to be 8-byte-aligned,
+// the sizes of each def type must also be a multiple of 8.
+//
+// If any of these asserts fail, we need to add or remove padding on 32-bit
+// machines (64-bit machines will have 8-byte alignment already due to
+// pointers, which all of these structs have).
+UPB_INLINE void _upb_DefType_CheckPadding(size_t size) {
+ UPB_ASSERT((size & UPB_DEFTYPE_MASK) == 0);
+}
+
+upb_deftype_t _upb_DefType_Type(upb_value v);
+
+upb_value _upb_DefType_Pack(const void* ptr, upb_deftype_t type);
+
+const void* _upb_DefType_Unpack(upb_value v, upb_deftype_t type);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_DEF_TYPE_H_ */
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void upb_DefPool_Free(upb_DefPool* s);
+
+upb_DefPool* upb_DefPool_New(void);
+
+const upb_MessageDef* upb_DefPool_FindMessageByName(const upb_DefPool* s,
+ const char* sym);
+
+const upb_MessageDef* upb_DefPool_FindMessageByNameWithSize(
+ const upb_DefPool* s, const char* sym, size_t len);
+
+const upb_EnumDef* upb_DefPool_FindEnumByName(const upb_DefPool* s,
+ const char* sym);
+
+const upb_EnumValueDef* upb_DefPool_FindEnumByNameval(const upb_DefPool* s,
+ const char* sym);
+
+const upb_FileDef* upb_DefPool_FindFileByName(const upb_DefPool* s,
+ const char* name);
+
+const upb_FileDef* upb_DefPool_FindFileByNameWithSize(const upb_DefPool* s,
+ const char* name,
+ size_t len);
+
+const upb_FieldDef* upb_DefPool_FindExtensionByNameWithSize(
+ const upb_DefPool* s, const char* name, size_t size);
+
+const upb_FieldDef* upb_DefPool_FindExtensionByName(const upb_DefPool* s,
+ const char* sym);
+
+const upb_ServiceDef* upb_DefPool_FindServiceByName(const upb_DefPool* s,
+ const char* name);
+
+const upb_ServiceDef* upb_DefPool_FindServiceByNameWithSize(
+ const upb_DefPool* s, const char* name, size_t size);
+
+const upb_FileDef* upb_DefPool_FindFileContainingSymbol(const upb_DefPool* s,
+ const char* name);
+
+const upb_FileDef* upb_DefPool_AddFile(
+ upb_DefPool* s, const google_protobuf_FileDescriptorProto* file_proto,
+ upb_Status* status);
+
+const upb_FieldDef* upb_DefPool_FindExtensionByNumber(const upb_DefPool* s,
+ const upb_MessageDef* m,
+ int32_t fieldnum);
+
+const upb_ExtensionRegistry* upb_DefPool_ExtensionRegistry(
+ const upb_DefPool* s);
+
+const upb_FieldDef** upb_DefPool_GetAllExtensions(const upb_DefPool* s,
+ const upb_MessageDef* m,
+ size_t* count);
+
+// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
+
+upb_Arena* _upb_DefPool_Arena(const upb_DefPool* s);
+size_t _upb_DefPool_BytesLoaded(const upb_DefPool* s);
+upb_ExtensionRegistry* _upb_DefPool_ExtReg(const upb_DefPool* s);
+const upb_FieldDef* _upb_DefPool_FindExtensionByMiniTable(
+ const upb_DefPool* s, const upb_MiniTable_Extension* ext);
+
+bool _upb_DefPool_InsertExt(upb_DefPool* s, const upb_MiniTable_Extension* ext,
+ upb_FieldDef* f);
+bool _upb_DefPool_InsertSym(upb_DefPool* s, upb_StringView sym, upb_value v,
+ upb_Status* status);
+bool _upb_DefPool_LookupSym(const upb_DefPool* s, const char* sym, size_t size,
+ upb_value* v);
+
+void** _upb_DefPool_ScratchData(const upb_DefPool* s);
+size_t* _upb_DefPool_ScratchSize(const upb_DefPool* s);
+
+// For generated code only: loads a generated descriptor.
+typedef struct _upb_DefPool_Init {
+ struct _upb_DefPool_Init** deps; // Dependencies of this file.
+ const upb_MiniTable_File* layout;
+ const char* filename;
+ upb_StringView descriptor; // Serialized descriptor.
+} _upb_DefPool_Init;
+
+bool _upb_DefPool_LoadDefInit(upb_DefPool* s, const _upb_DefPool_Init* init);
+
+// Should only be directly called by tests. This variant lets us suppress
+// the use of compiled-in tables, forcing a rebuild of the tables at runtime.
+bool _upb_DefPool_LoadDefInitEx(upb_DefPool* s, const _upb_DefPool_Init* init,
+ bool rebuild_minitable);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_DEF_POOL_H_ */
+
+// IWYU pragma: private, include "third_party/upb/upb/reflection/def.h"
+
+#ifndef UPB_REFLECTION_ENUM_DEF_H_
+#define UPB_REFLECTION_ENUM_DEF_H_
+
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool upb_EnumDef_CheckNumber(const upb_EnumDef* e, int32_t num);
+const upb_MessageDef* upb_EnumDef_ContainingType(const upb_EnumDef* e);
+int32_t upb_EnumDef_Default(const upb_EnumDef* e);
+const upb_FileDef* upb_EnumDef_File(const upb_EnumDef* e);
+const upb_EnumValueDef* upb_EnumDef_FindValueByName(const upb_EnumDef* e,
+ const char* name);
+const upb_EnumValueDef* upb_EnumDef_FindValueByNameWithSize(
+ const upb_EnumDef* e, const char* name, size_t size);
+const upb_EnumValueDef* upb_EnumDef_FindValueByNumber(const upb_EnumDef* e,
+ int32_t num);
+const char* upb_EnumDef_FullName(const upb_EnumDef* e);
+bool upb_EnumDef_HasOptions(const upb_EnumDef* e);
+
+// Creates a mini descriptor string for an enum, returns true on success.
+bool upb_EnumDef_MiniDescriptorEncode(const upb_EnumDef* e, upb_Arena* a,
+ upb_StringView* out);
+
+const char* upb_EnumDef_Name(const upb_EnumDef* e);
+const google_protobuf_EnumOptions* upb_EnumDef_Options(const upb_EnumDef* e);
+const upb_EnumValueDef* upb_EnumDef_Value(const upb_EnumDef* e, int i);
+int upb_EnumDef_ValueCount(const upb_EnumDef* e);
+
+// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
+
+upb_EnumDef* _upb_EnumDef_At(const upb_EnumDef* e, int i);
+bool _upb_EnumDef_Insert(upb_EnumDef* e, upb_EnumValueDef* v, upb_Arena* a);
+const upb_MiniTable_Enum* _upb_EnumDef_MiniTable(const upb_EnumDef* e);
+
+// Allocate and initialize an array of |n| enum defs.
+upb_EnumDef* _upb_EnumDefs_New(upb_DefBuilder* ctx, int n,
+ const google_protobuf_EnumDescriptorProto* const* protos,
+ const upb_MessageDef* containing_type);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_ENUM_DEF_H_ */
+
+// IWYU pragma: private, include "third_party/upb/upb/reflection/def.h"
+
+#ifndef UPB_REFLECTION_ENUM_VALUE_DEF_H_
+#define UPB_REFLECTION_ENUM_VALUE_DEF_H_
+
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const upb_EnumDef* upb_EnumValueDef_Enum(const upb_EnumValueDef* v);
+const char* upb_EnumValueDef_FullName(const upb_EnumValueDef* v);
+bool upb_EnumValueDef_HasOptions(const upb_EnumValueDef* v);
+uint32_t upb_EnumValueDef_Index(const upb_EnumValueDef* v);
+const char* upb_EnumValueDef_Name(const upb_EnumValueDef* v);
+int32_t upb_EnumValueDef_Number(const upb_EnumValueDef* v);
+const google_protobuf_EnumValueOptions* upb_EnumValueDef_Options(
+ const upb_EnumValueDef* v);
+
+// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
+
+upb_EnumValueDef* _upb_EnumValueDef_At(const upb_EnumValueDef* v, int i);
+
+// Allocate and initialize an array of |n| enum value defs owned by |e|.
+upb_EnumValueDef* _upb_EnumValueDefs_New(
+ upb_DefBuilder* ctx, const char* prefix, int n,
+ const google_protobuf_EnumValueDescriptorProto* const* protos, upb_EnumDef* e,
+ bool* is_sorted);
+
+const upb_EnumValueDef** _upb_EnumValueDefs_Sorted(const upb_EnumValueDef* v,
+ int n, upb_Arena* a);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_ENUM_VALUE_DEF_H_ */
+
+// IWYU pragma: private, include "third_party/upb/upb/reflection/def.h"
+
+#ifndef UPB_REFLECTION_EXTENSION_RANGE_H_
+#define UPB_REFLECTION_EXTENSION_RANGE_H_
+
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t upb_ExtensionRange_Start(const upb_ExtensionRange* r);
+int32_t upb_ExtensionRange_End(const upb_ExtensionRange* r);
+
+bool upb_ExtensionRange_HasOptions(const upb_ExtensionRange* r);
+const google_protobuf_ExtensionRangeOptions* upb_ExtensionRange_Options(
+ const upb_ExtensionRange* r);
+
+// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
+
+upb_ExtensionRange* _upb_ExtensionRange_At(const upb_ExtensionRange* r, int i);
+
+// Allocate and initialize an array of |n| extension ranges owned by |m|.
+upb_ExtensionRange* _upb_ExtensionRanges_New(
+ upb_DefBuilder* ctx, int n,
+ const google_protobuf_DescriptorProto_ExtensionRange* const* protos,
+ const upb_MessageDef* m);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_EXTENSION_RANGE_H_ */
+
+// IWYU pragma: private, include "third_party/upb/upb/reflection/def.h"
+
+#ifndef UPB_REFLECTION_FIELD_DEF_H_
+#define UPB_REFLECTION_FIELD_DEF_H_
+
+
+// Must be last.
+
+// Maximum field number allowed for FieldDefs.
+// This is an inherent limit of the protobuf wire format.
+#define kUpb_MaxFieldNumber ((1 << 29) - 1)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const upb_OneofDef* upb_FieldDef_ContainingOneof(const upb_FieldDef* f);
+const upb_MessageDef* upb_FieldDef_ContainingType(const upb_FieldDef* f);
+upb_CType upb_FieldDef_CType(const upb_FieldDef* f);
+const upb_EnumDef* upb_FieldDef_EnumSubDef(const upb_FieldDef* f);
+const upb_MessageDef* upb_FieldDef_ExtensionScope(const upb_FieldDef* f);
+const upb_FileDef* upb_FieldDef_File(const upb_FieldDef* f);
+const char* upb_FieldDef_FullName(const upb_FieldDef* f);
+bool upb_FieldDef_HasDefault(const upb_FieldDef* f);
+bool upb_FieldDef_HasJsonName(const upb_FieldDef* f);
+bool upb_FieldDef_HasOptions(const upb_FieldDef* f);
+bool upb_FieldDef_HasPresence(const upb_FieldDef* f);
+bool upb_FieldDef_HasSubDef(const upb_FieldDef* f);
+uint32_t upb_FieldDef_Index(const upb_FieldDef* f);
+bool upb_FieldDef_IsExtension(const upb_FieldDef* f);
+bool upb_FieldDef_IsMap(const upb_FieldDef* f);
+bool upb_FieldDef_IsOptional(const upb_FieldDef* f);
+bool upb_FieldDef_IsPacked(const upb_FieldDef* f);
+bool upb_FieldDef_IsPrimitive(const upb_FieldDef* f);
+bool upb_FieldDef_IsRepeated(const upb_FieldDef* f);
+bool upb_FieldDef_IsRequired(const upb_FieldDef* f);
+bool upb_FieldDef_IsString(const upb_FieldDef* f);
+bool upb_FieldDef_IsSubMessage(const upb_FieldDef* f);
+const char* upb_FieldDef_JsonName(const upb_FieldDef* f);
+upb_Label upb_FieldDef_Label(const upb_FieldDef* f);
+const upb_MessageDef* upb_FieldDef_MessageSubDef(const upb_FieldDef* f);
+
+// Creates a mini descriptor string for a field, returns true on success.
+bool upb_FieldDef_MiniDescriptorEncode(const upb_FieldDef* f, upb_Arena* a,
+ upb_StringView* out);
+
+const upb_MiniTable_Field* upb_FieldDef_MiniTable(const upb_FieldDef* f);
+const char* upb_FieldDef_Name(const upb_FieldDef* f);
+uint32_t upb_FieldDef_Number(const upb_FieldDef* f);
+const google_protobuf_FieldOptions* upb_FieldDef_Options(const upb_FieldDef* f);
+const upb_OneofDef* upb_FieldDef_RealContainingOneof(const upb_FieldDef* f);
+upb_FieldType upb_FieldDef_Type(const upb_FieldDef* f);
+
+// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
+
+upb_FieldDef* _upb_FieldDef_At(const upb_FieldDef* f, int i);
+
+const upb_MiniTable_Extension* _upb_FieldDef_ExtensionMiniTable(
+ const upb_FieldDef* f);
+bool _upb_FieldDef_IsClosedEnum(const upb_FieldDef* f);
+bool _upb_FieldDef_IsProto3Optional(const upb_FieldDef* f);
+int _upb_FieldDef_LayoutIndex(const upb_FieldDef* f);
+uint64_t _upb_FieldDef_Modifiers(const upb_FieldDef* f);
+void _upb_FieldDef_Resolve(upb_DefBuilder* ctx, const char* prefix,
+ upb_FieldDef* f);
+
+// Allocate and initialize an array of |n| field defs.
+upb_FieldDef* _upb_FieldDefs_New(
+ upb_DefBuilder* ctx, int n,
+ const google_protobuf_FieldDescriptorProto* const* protos, const char* prefix,
+ upb_MessageDef* m, bool* is_sorted);
+
+// Allocate and return a list of pointers to the |n| field defs in |ff|,
+// sorted by field number.
+const upb_FieldDef** _upb_FieldDefs_Sorted(const upb_FieldDef* f, int n,
+ upb_Arena* a);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_FIELD_DEF_H_ */
+
+// IWYU pragma: private, include "third_party/upb/upb/reflection/def.h"
+
+#ifndef UPB_REFLECTION_FILE_DEF_H_
+#define UPB_REFLECTION_FILE_DEF_H_
+
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const upb_FileDef* upb_FileDef_Dependency(const upb_FileDef* f, int i);
+int upb_FileDef_DependencyCount(const upb_FileDef* f);
+bool upb_FileDef_HasOptions(const upb_FileDef* f);
+const char* upb_FileDef_Name(const upb_FileDef* f);
+const google_protobuf_FileOptions* upb_FileDef_Options(const upb_FileDef* f);
+const char* upb_FileDef_Package(const upb_FileDef* f);
+const upb_DefPool* upb_FileDef_Pool(const upb_FileDef* f);
+
+const upb_FileDef* upb_FileDef_PublicDependency(const upb_FileDef* f, int i);
+int upb_FileDef_PublicDependencyCount(const upb_FileDef* f);
+
+const upb_ServiceDef* upb_FileDef_Service(const upb_FileDef* f, int i);
+int upb_FileDef_ServiceCount(const upb_FileDef* f);
+
+upb_Syntax upb_FileDef_Syntax(const upb_FileDef* f);
+
+const upb_EnumDef* upb_FileDef_TopLevelEnum(const upb_FileDef* f, int i);
+int upb_FileDef_TopLevelEnumCount(const upb_FileDef* f);
+
+const upb_FieldDef* upb_FileDef_TopLevelExtension(const upb_FileDef* f, int i);
+int upb_FileDef_TopLevelExtensionCount(const upb_FileDef* f);
+
+const upb_MessageDef* upb_FileDef_TopLevelMessage(const upb_FileDef* f, int i);
+int upb_FileDef_TopLevelMessageCount(const upb_FileDef* f);
+
+const upb_FileDef* upb_FileDef_WeakDependency(const upb_FileDef* f, int i);
+int upb_FileDef_WeakDependencyCount(const upb_FileDef* f);
+
+// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
+
+const upb_MiniTable_Extension* _upb_FileDef_ExtensionMiniTable(
+ const upb_FileDef* f, int i);
+const int32_t* _upb_FileDef_PublicDependencyIndexes(const upb_FileDef* f);
+const int32_t* _upb_FileDef_WeakDependencyIndexes(const upb_FileDef* f);
+
+// upb_FileDef_Package() returns "" if f->package is NULL, this does not.
+const char* _upb_FileDef_RawPackage(const upb_FileDef* f);
+
+void _upb_FileDef_Create(upb_DefBuilder* ctx,
+ const google_protobuf_FileDescriptorProto* file_proto);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_FILE_DEF_H_ */
+
+// IWYU pragma: private, include "third_party/upb/upb/reflection/def.h"
+
+#ifndef UPB_REFLECTION_MESSAGE_DEF_H_
+#define UPB_REFLECTION_MESSAGE_DEF_H_
+
+
+// Must be last.
+
+// Well-known field tag numbers for map-entry messages.
+#define kUpb_MapEntry_KeyFieldNumber 1
+#define kUpb_MapEntry_ValueFieldNumber 2
+
+// Well-known field tag numbers for Any messages.
+#define kUpb_Any_TypeFieldNumber 1
+#define kUpb_Any_ValueFieldNumber 2
+
+// Well-known field tag numbers for duration messages.
+#define kUpb_Duration_SecondsFieldNumber 1
+#define kUpb_Duration_NanosFieldNumber 2
+
+// Well-known field tag numbers for timestamp messages.
+#define kUpb_Timestamp_SecondsFieldNumber 1
+#define kUpb_Timestamp_NanosFieldNumber 2
+
+// All the different kind of well known type messages. For simplicity of check,
+// number wrappers and string wrappers are grouped together. Make sure the
+// order and number of these groups are not changed.
typedef enum {
kUpb_WellKnown_Unspecified,
kUpb_WellKnown_Any,
kUpb_WellKnown_FieldMask,
kUpb_WellKnown_Duration,
kUpb_WellKnown_Timestamp,
- /* number wrappers */
+
+ // number wrappers
kUpb_WellKnown_DoubleValue,
kUpb_WellKnown_FloatValue,
kUpb_WellKnown_Int64Value,
kUpb_WellKnown_UInt64Value,
kUpb_WellKnown_Int32Value,
kUpb_WellKnown_UInt32Value,
- /* string wrappers */
+
+ // string wrappers
kUpb_WellKnown_StringValue,
kUpb_WellKnown_BytesValue,
kUpb_WellKnown_BoolValue,
kUpb_WellKnown_Value,
kUpb_WellKnown_ListValue,
- kUpb_WellKnown_Struct
+ kUpb_WellKnown_Struct,
} upb_WellKnown;
-/* upb_FieldDef ***************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
-/* Maximum field number allowed for FieldDefs. This is an inherent limit of the
- * protobuf wire format. */
-#define kUpb_MaxFieldNumber ((1 << 29) - 1)
-
-const google_protobuf_FieldOptions* upb_FieldDef_Options(const upb_FieldDef* f);
-bool upb_FieldDef_HasOptions(const upb_FieldDef* f);
-const char* upb_FieldDef_FullName(const upb_FieldDef* f);
-upb_CType upb_FieldDef_CType(const upb_FieldDef* f);
-upb_FieldType upb_FieldDef_Type(const upb_FieldDef* f);
-upb_Label upb_FieldDef_Label(const upb_FieldDef* f);
-uint32_t upb_FieldDef_Number(const upb_FieldDef* f);
-const char* upb_FieldDef_Name(const upb_FieldDef* f);
-const char* upb_FieldDef_JsonName(const upb_FieldDef* f);
-bool upb_FieldDef_HasJsonName(const upb_FieldDef* f);
-bool upb_FieldDef_IsExtension(const upb_FieldDef* f);
-bool upb_FieldDef_IsPacked(const upb_FieldDef* f);
-const upb_FileDef* upb_FieldDef_File(const upb_FieldDef* f);
-const upb_MessageDef* upb_FieldDef_ContainingType(const upb_FieldDef* f);
-const upb_MessageDef* upb_FieldDef_ExtensionScope(const upb_FieldDef* f);
-const upb_OneofDef* upb_FieldDef_ContainingOneof(const upb_FieldDef* f);
-const upb_OneofDef* upb_FieldDef_RealContainingOneof(const upb_FieldDef* f);
-uint32_t upb_FieldDef_Index(const upb_FieldDef* f);
-bool upb_FieldDef_IsSubMessage(const upb_FieldDef* f);
-bool upb_FieldDef_IsString(const upb_FieldDef* f);
-bool upb_FieldDef_IsRepeated(const upb_FieldDef* f);
-bool upb_FieldDef_IsPrimitive(const upb_FieldDef* f);
-bool upb_FieldDef_IsMap(const upb_FieldDef* f);
-bool upb_FieldDef_HasDefault(const upb_FieldDef* f);
-bool upb_FieldDef_HasSubDef(const upb_FieldDef* f);
-bool upb_FieldDef_HasPresence(const upb_FieldDef* f);
-const upb_MessageDef* upb_FieldDef_MessageSubDef(const upb_FieldDef* f);
-const upb_EnumDef* upb_FieldDef_EnumSubDef(const upb_FieldDef* f);
-const upb_MiniTable_Field* upb_FieldDef_MiniTable(const upb_FieldDef* f);
-const upb_MiniTable_Extension* _upb_FieldDef_ExtensionMiniTable(
- const upb_FieldDef* f);
-bool _upb_FieldDef_IsProto3Optional(const upb_FieldDef* f);
-
-/* upb_OneofDef ***************************************************************/
-
-const google_protobuf_OneofOptions* upb_OneofDef_Options(const upb_OneofDef* o);
-bool upb_OneofDef_HasOptions(const upb_OneofDef* o);
-const char* upb_OneofDef_Name(const upb_OneofDef* o);
-const upb_MessageDef* upb_OneofDef_ContainingType(const upb_OneofDef* o);
-uint32_t upb_OneofDef_Index(const upb_OneofDef* o);
-bool upb_OneofDef_IsSynthetic(const upb_OneofDef* o);
-int upb_OneofDef_FieldCount(const upb_OneofDef* o);
-const upb_FieldDef* upb_OneofDef_Field(const upb_OneofDef* o, int i);
-
-/* Oneof lookups:
- * - ntof: look up a field by name.
- * - ntofz: look up a field by name (as a null-terminated string).
- * - itof: look up a field by number. */
-const upb_FieldDef* upb_OneofDef_LookupNameWithSize(const upb_OneofDef* o,
- const char* name,
- size_t length);
-UPB_INLINE const upb_FieldDef* upb_OneofDef_LookupName(const upb_OneofDef* o,
- const char* name) {
- return upb_OneofDef_LookupNameWithSize(o, name, strlen(name));
-}
-const upb_FieldDef* upb_OneofDef_LookupNumber(const upb_OneofDef* o,
- uint32_t num);
-
-/* upb_MessageDef *************************************************************/
-
-/* Well-known field tag numbers for map-entry messages. */
-#define kUpb_MapEntry_KeyFieldNumber 1
-#define kUpb_MapEntry_ValueFieldNumber 2
-
-/* Well-known field tag numbers for Any messages. */
-#define kUpb_Any_TypeFieldNumber 1
-#define kUpb_Any_ValueFieldNumber 2
-
-/* Well-known field tag numbers for timestamp messages. */
-#define kUpb_Duration_SecondsFieldNumber 1
-#define kUpb_Duration_NanosFieldNumber 2
-
-/* Well-known field tag numbers for duration messages. */
-#define kUpb_Timestamp_SecondsFieldNumber 1
-#define kUpb_Timestamp_NanosFieldNumber 2
-
-const google_protobuf_MessageOptions* upb_MessageDef_Options(
- const upb_MessageDef* m);
-bool upb_MessageDef_HasOptions(const upb_MessageDef* m);
-const char* upb_MessageDef_FullName(const upb_MessageDef* m);
-const upb_FileDef* upb_MessageDef_File(const upb_MessageDef* m);
const upb_MessageDef* upb_MessageDef_ContainingType(const upb_MessageDef* m);
-const char* upb_MessageDef_Name(const upb_MessageDef* m);
-upb_Syntax upb_MessageDef_Syntax(const upb_MessageDef* m);
-upb_WellKnown upb_MessageDef_WellKnownType(const upb_MessageDef* m);
-int upb_MessageDef_ExtensionRangeCount(const upb_MessageDef* m);
-int upb_MessageDef_FieldCount(const upb_MessageDef* m);
-int upb_MessageDef_OneofCount(const upb_MessageDef* m);
+
const upb_ExtensionRange* upb_MessageDef_ExtensionRange(const upb_MessageDef* m,
int i);
+int upb_MessageDef_ExtensionRangeCount(const upb_MessageDef* m);
+
const upb_FieldDef* upb_MessageDef_Field(const upb_MessageDef* m, int i);
-const upb_OneofDef* upb_MessageDef_Oneof(const upb_MessageDef* m, int i);
-const upb_FieldDef* upb_MessageDef_FindFieldByNumber(const upb_MessageDef* m,
- uint32_t i);
-const upb_FieldDef* upb_MessageDef_FindFieldByNameWithSize(
- const upb_MessageDef* m, const char* name, size_t len);
-const upb_OneofDef* upb_MessageDef_FindOneofByNameWithSize(
- const upb_MessageDef* m, const char* name, size_t len);
-const upb_MiniTable* upb_MessageDef_MiniTable(const upb_MessageDef* m);
+int upb_MessageDef_FieldCount(const upb_MessageDef* m);
-UPB_INLINE const upb_OneofDef* upb_MessageDef_FindOneofByName(
+const upb_FileDef* upb_MessageDef_File(const upb_MessageDef* m);
+
+// Returns a field by either JSON name or regular proto name.
+const upb_FieldDef* upb_MessageDef_FindByJsonNameWithSize(
+ const upb_MessageDef* m, const char* name, size_t size);
+UPB_INLINE const upb_FieldDef* upb_MessageDef_FindByJsonName(
const upb_MessageDef* m, const char* name) {
- return upb_MessageDef_FindOneofByNameWithSize(m, name, strlen(name));
+ return upb_MessageDef_FindByJsonNameWithSize(m, name, strlen(name));
}
-UPB_INLINE const upb_FieldDef* upb_MessageDef_FindFieldByName(
- const upb_MessageDef* m, const char* name) {
- return upb_MessageDef_FindFieldByNameWithSize(m, name, strlen(name));
-}
-
-UPB_INLINE bool upb_MessageDef_IsMapEntry(const upb_MessageDef* m) {
- return google_protobuf_MessageOptions_map_entry(upb_MessageDef_Options(m));
-}
-
-/* Nested entities. */
-int upb_MessageDef_NestedMessageCount(const upb_MessageDef* m);
-int upb_MessageDef_NestedEnumCount(const upb_MessageDef* m);
-int upb_MessageDef_NestedExtensionCount(const upb_MessageDef* m);
-const upb_MessageDef* upb_MessageDef_NestedMessage(const upb_MessageDef* m,
- int i);
-const upb_EnumDef* upb_MessageDef_NestedEnum(const upb_MessageDef* m, int i);
-const upb_FieldDef* upb_MessageDef_NestedExtension(const upb_MessageDef* m,
- int i);
-
-/* Lookup of either field or oneof by name. Returns whether either was found.
- * If the return is true, then the found def will be set, and the non-found
- * one set to NULL. */
+// Lookup of either field or oneof by name. Returns whether either was found.
+// If the return is true, then the found def will be set, and the non-found
+// one set to NULL.
bool upb_MessageDef_FindByNameWithSize(const upb_MessageDef* m,
- const char* name, size_t len,
+ const char* name, size_t size,
const upb_FieldDef** f,
const upb_OneofDef** o);
-
UPB_INLINE bool upb_MessageDef_FindByName(const upb_MessageDef* m,
const char* name,
const upb_FieldDef** f,
@@ -5155,212 +6472,280 @@
return upb_MessageDef_FindByNameWithSize(m, name, strlen(name), f, o);
}
-/* Returns a field by either JSON name or regular proto name. */
-const upb_FieldDef* upb_MessageDef_FindByJsonNameWithSize(
- const upb_MessageDef* m, const char* name, size_t len);
-UPB_INLINE const upb_FieldDef* upb_MessageDef_FindByJsonName(
- const upb_MessageDef* m, const char* name) {
- return upb_MessageDef_FindByJsonNameWithSize(m, name, strlen(name));
-}
+const upb_FieldDef* upb_MessageDef_FindFieldByName(const upb_MessageDef* m,
+ const char* name);
+const upb_FieldDef* upb_MessageDef_FindFieldByNameWithSize(
+ const upb_MessageDef* m, const char* name, size_t size);
+const upb_FieldDef* upb_MessageDef_FindFieldByNumber(const upb_MessageDef* m,
+ uint32_t i);
+const upb_OneofDef* upb_MessageDef_FindOneofByName(const upb_MessageDef* m,
+ const char* name);
+const upb_OneofDef* upb_MessageDef_FindOneofByNameWithSize(
+ const upb_MessageDef* m, const char* name, size_t size);
+const char* upb_MessageDef_FullName(const upb_MessageDef* m);
+bool upb_MessageDef_HasOptions(const upb_MessageDef* m);
+bool upb_MessageDef_IsMapEntry(const upb_MessageDef* m);
+bool upb_MessageDef_IsMessageSet(const upb_MessageDef* m);
-/* upb_ExtensionRange *********************************************************/
+// Creates a mini descriptor string for a message, returns true on success.
+bool upb_MessageDef_MiniDescriptorEncode(const upb_MessageDef* m, upb_Arena* a,
+ upb_StringView* out);
-const google_protobuf_ExtensionRangeOptions* upb_ExtensionRange_Options(
- const upb_ExtensionRange* r);
-bool upb_ExtensionRange_HasOptions(const upb_ExtensionRange* r);
-int32_t upb_ExtensionRange_Start(const upb_ExtensionRange* r);
-int32_t upb_ExtensionRange_End(const upb_ExtensionRange* r);
+const upb_MiniTable* upb_MessageDef_MiniTable(const upb_MessageDef* m);
+const char* upb_MessageDef_Name(const upb_MessageDef* m);
-/* upb_EnumDef ****************************************************************/
+const upb_EnumDef* upb_MessageDef_NestedEnum(const upb_MessageDef* m, int i);
+const upb_FieldDef* upb_MessageDef_NestedExtension(const upb_MessageDef* m,
+ int i);
+const upb_MessageDef* upb_MessageDef_NestedMessage(const upb_MessageDef* m,
+ int i);
-const google_protobuf_EnumOptions* upb_EnumDef_Options(const upb_EnumDef* e);
-bool upb_EnumDef_HasOptions(const upb_EnumDef* e);
-const char* upb_EnumDef_FullName(const upb_EnumDef* e);
-const char* upb_EnumDef_Name(const upb_EnumDef* e);
-const upb_FileDef* upb_EnumDef_File(const upb_EnumDef* e);
-const upb_MessageDef* upb_EnumDef_ContainingType(const upb_EnumDef* e);
-int32_t upb_EnumDef_Default(const upb_EnumDef* e);
-int upb_EnumDef_ValueCount(const upb_EnumDef* e);
-const upb_EnumValueDef* upb_EnumDef_Value(const upb_EnumDef* e, int i);
+int upb_MessageDef_NestedEnumCount(const upb_MessageDef* m);
+int upb_MessageDef_NestedExtensionCount(const upb_MessageDef* m);
+int upb_MessageDef_NestedMessageCount(const upb_MessageDef* m);
-const upb_EnumValueDef* upb_EnumDef_FindValueByNameWithSize(
- const upb_EnumDef* e, const char* name, size_t len);
-const upb_EnumValueDef* upb_EnumDef_FindValueByNumber(const upb_EnumDef* e,
- int32_t num);
-bool upb_EnumDef_CheckNumber(const upb_EnumDef* e, int32_t num);
+const upb_OneofDef* upb_MessageDef_Oneof(const upb_MessageDef* m, int i);
+int upb_MessageDef_OneofCount(const upb_MessageDef* m);
-// Convenience wrapper.
-UPB_INLINE const upb_EnumValueDef* upb_EnumDef_FindValueByName(
- const upb_EnumDef* e, const char* name) {
- return upb_EnumDef_FindValueByNameWithSize(e, name, strlen(name));
-}
+const google_protobuf_MessageOptions* upb_MessageDef_Options(const upb_MessageDef* m);
+upb_Syntax upb_MessageDef_Syntax(const upb_MessageDef* m);
+upb_WellKnown upb_MessageDef_WellKnownType(const upb_MessageDef* m);
-/* upb_EnumValueDef ***********************************************************/
+// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
-const google_protobuf_EnumValueOptions* upb_EnumValueDef_Options(
- const upb_EnumValueDef* e);
-bool upb_EnumValueDef_HasOptions(const upb_EnumValueDef* e);
-const char* upb_EnumValueDef_FullName(const upb_EnumValueDef* e);
-const char* upb_EnumValueDef_Name(const upb_EnumValueDef* e);
-int32_t upb_EnumValueDef_Number(const upb_EnumValueDef* e);
-uint32_t upb_EnumValueDef_Index(const upb_EnumValueDef* e);
-const upb_EnumDef* upb_EnumValueDef_Enum(const upb_EnumValueDef* e);
+upb_MessageDef* _upb_MessageDef_At(const upb_MessageDef* m, int i);
+bool _upb_MessageDef_InMessageSet(const upb_MessageDef* m);
+bool _upb_MessageDef_Insert(upb_MessageDef* m, const char* name, size_t size,
+ upb_value v, upb_Arena* a);
+void _upb_MessageDef_InsertField(upb_DefBuilder* ctx, upb_MessageDef* m,
+ const upb_FieldDef* f);
+bool _upb_MessageDef_IsValidExtensionNumber(const upb_MessageDef* m, int n);
+void _upb_MessageDef_LinkMiniTable(upb_DefBuilder* ctx,
+ const upb_MessageDef* m);
+void _upb_MessageDef_Resolve(upb_DefBuilder* ctx, upb_MessageDef* m);
-/* upb_FileDef ****************************************************************/
-
-const google_protobuf_FileOptions* upb_FileDef_Options(const upb_FileDef* f);
-bool upb_FileDef_HasOptions(const upb_FileDef* f);
-const char* upb_FileDef_Name(const upb_FileDef* f);
-const char* upb_FileDef_Package(const upb_FileDef* f);
-upb_Syntax upb_FileDef_Syntax(const upb_FileDef* f);
-int upb_FileDef_DependencyCount(const upb_FileDef* f);
-int upb_FileDef_PublicDependencyCount(const upb_FileDef* f);
-int upb_FileDef_WeakDependencyCount(const upb_FileDef* f);
-int upb_FileDef_TopLevelMessageCount(const upb_FileDef* f);
-int upb_FileDef_TopLevelEnumCount(const upb_FileDef* f);
-int upb_FileDef_TopLevelExtensionCount(const upb_FileDef* f);
-int upb_FileDef_ServiceCount(const upb_FileDef* f);
-const upb_FileDef* upb_FileDef_Dependency(const upb_FileDef* f, int i);
-const upb_FileDef* upb_FileDef_PublicDependency(const upb_FileDef* f, int i);
-const upb_FileDef* upb_FileDef_WeakDependency(const upb_FileDef* f, int i);
-const upb_MessageDef* upb_FileDef_TopLevelMessage(const upb_FileDef* f, int i);
-const upb_EnumDef* upb_FileDef_TopLevelEnum(const upb_FileDef* f, int i);
-const upb_FieldDef* upb_FileDef_TopLevelExtension(const upb_FileDef* f, int i);
-const upb_ServiceDef* upb_FileDef_Service(const upb_FileDef* f, int i);
-const upb_DefPool* upb_FileDef_Pool(const upb_FileDef* f);
-const int32_t* _upb_FileDef_PublicDependencyIndexes(const upb_FileDef* f);
-const int32_t* _upb_FileDef_WeakDependencyIndexes(const upb_FileDef* f);
-
-/* upb_MethodDef **************************************************************/
-
-const google_protobuf_MethodOptions* upb_MethodDef_Options(
- const upb_MethodDef* m);
-bool upb_MethodDef_HasOptions(const upb_MethodDef* m);
-const char* upb_MethodDef_FullName(const upb_MethodDef* m);
-int upb_MethodDef_Index(const upb_MethodDef* m);
-const char* upb_MethodDef_Name(const upb_MethodDef* m);
-const upb_ServiceDef* upb_MethodDef_Service(const upb_MethodDef* m);
-const upb_MessageDef* upb_MethodDef_InputType(const upb_MethodDef* m);
-const upb_MessageDef* upb_MethodDef_OutputType(const upb_MethodDef* m);
-bool upb_MethodDef_ClientStreaming(const upb_MethodDef* m);
-bool upb_MethodDef_ServerStreaming(const upb_MethodDef* m);
-
-/* upb_ServiceDef *************************************************************/
-
-const google_protobuf_ServiceOptions* upb_ServiceDef_Options(
- const upb_ServiceDef* s);
-bool upb_ServiceDef_HasOptions(const upb_ServiceDef* s);
-const char* upb_ServiceDef_FullName(const upb_ServiceDef* s);
-const char* upb_ServiceDef_Name(const upb_ServiceDef* s);
-int upb_ServiceDef_Index(const upb_ServiceDef* s);
-const upb_FileDef* upb_ServiceDef_File(const upb_ServiceDef* s);
-int upb_ServiceDef_MethodCount(const upb_ServiceDef* s);
-const upb_MethodDef* upb_ServiceDef_Method(const upb_ServiceDef* s, int i);
-const upb_MethodDef* upb_ServiceDef_FindMethodByName(const upb_ServiceDef* s,
- const char* name);
-
-/* upb_DefPool ****************************************************************/
-
-upb_DefPool* upb_DefPool_New(void);
-void upb_DefPool_Free(upb_DefPool* s);
-const upb_MessageDef* upb_DefPool_FindMessageByName(const upb_DefPool* s,
- const char* sym);
-const upb_MessageDef* upb_DefPool_FindMessageByNameWithSize(
- const upb_DefPool* s, const char* sym, size_t len);
-const upb_EnumDef* upb_DefPool_FindEnumByName(const upb_DefPool* s,
- const char* sym);
-const upb_EnumValueDef* upb_DefPool_FindEnumByNameval(const upb_DefPool* s,
- const char* sym);
-const upb_FieldDef* upb_DefPool_FindExtensionByName(const upb_DefPool* s,
- const char* sym);
-const upb_FieldDef* upb_DefPool_FindExtensionByNameWithSize(
- const upb_DefPool* s, const char* sym, size_t len);
-const upb_FileDef* upb_DefPool_FindFileByName(const upb_DefPool* s,
- const char* name);
-const upb_ServiceDef* upb_DefPool_FindServiceByName(const upb_DefPool* s,
- const char* name);
-const upb_ServiceDef* upb_DefPool_FindServiceByNameWithSize(
- const upb_DefPool* s, const char* name, size_t size);
-const upb_FileDef* upb_DefPool_FindFileContainingSymbol(const upb_DefPool* s,
- const char* name);
-const upb_FileDef* upb_DefPool_FindFileByNameWithSize(const upb_DefPool* s,
- const char* name,
- size_t len);
-const upb_FileDef* upb_DefPool_AddFile(
- upb_DefPool* s, const google_protobuf_FileDescriptorProto* file,
- upb_Status* status);
-size_t _upb_DefPool_BytesLoaded(const upb_DefPool* s);
-upb_Arena* _upb_DefPool_Arena(const upb_DefPool* s);
-const upb_FieldDef* _upb_DefPool_FindExtensionByMiniTable(
- const upb_DefPool* s, const upb_MiniTable_Extension* ext);
-const upb_FieldDef* upb_DefPool_FindExtensionByNumber(const upb_DefPool* s,
- const upb_MessageDef* m,
- int32_t fieldnum);
-const upb_ExtensionRegistry* upb_DefPool_ExtensionRegistry(
- const upb_DefPool* s);
-const upb_FieldDef** upb_DefPool_GetAllExtensions(const upb_DefPool* s,
- const upb_MessageDef* m,
- size_t* count);
-
-/* For generated code only: loads a generated descriptor. */
-typedef struct _upb_DefPool_Init {
- struct _upb_DefPool_Init** deps; /* Dependencies of this file. */
- const upb_MiniTable_File* layout;
- const char* filename;
- upb_StringView descriptor; /* Serialized descriptor. */
-} _upb_DefPool_Init;
-
-// Should only be directly called by tests. This variant lets us suppress
-// the use of compiled-in tables, forcing a rebuild of the tables at runtime.
-bool _upb_DefPool_LoadDefInitEx(upb_DefPool* s, const _upb_DefPool_Init* init,
- bool rebuild_minitable);
-
-UPB_INLINE bool _upb_DefPool_LoadDefInit(upb_DefPool* s,
- const _upb_DefPool_Init* init) {
- return _upb_DefPool_LoadDefInitEx(s, init, false);
-}
-
+// Allocate and initialize an array of |n| message defs.
+upb_MessageDef* _upb_MessageDefs_New(
+ upb_DefBuilder* ctx, int n, const google_protobuf_DescriptorProto* const* protos,
+ const upb_MessageDef* containing_type);
#ifdef __cplusplus
} /* extern "C" */
-#endif /* __cplusplus */
+#endif
-#endif /* UPB_DEF_H_ */
-/** upb/reflection.h ************************************************************/
-#ifndef UPB_REFLECTION_H_
-#define UPB_REFLECTION_H_
+#endif /* UPB_REFLECTION_MESSAGE_DEF_H_ */
+// IWYU pragma: private, include "third_party/upb/upb/reflection/def.h"
+
+#ifndef UPB_REFLECTION_METHOD_DEF_H_
+#define UPB_REFLECTION_METHOD_DEF_H_
+
+
+// Must be last.
#ifdef __cplusplus
extern "C" {
#endif
-typedef union {
- bool bool_val;
- float float_val;
- double double_val;
- int32_t int32_val;
- int64_t int64_val;
- uint32_t uint32_val;
- uint64_t uint64_val;
- const upb_Map* map_val;
- const upb_Message* msg_val;
- const upb_Array* array_val;
- upb_StringView str_val;
-} upb_MessageValue;
+bool upb_MethodDef_ClientStreaming(const upb_MethodDef* m);
+const char* upb_MethodDef_FullName(const upb_MethodDef* m);
+bool upb_MethodDef_HasOptions(const upb_MethodDef* m);
+int upb_MethodDef_Index(const upb_MethodDef* m);
+const upb_MessageDef* upb_MethodDef_InputType(const upb_MethodDef* m);
+const char* upb_MethodDef_Name(const upb_MethodDef* m);
+const google_protobuf_MethodOptions* upb_MethodDef_Options(const upb_MethodDef* m);
+const upb_MessageDef* upb_MethodDef_OutputType(const upb_MethodDef* m);
+bool upb_MethodDef_ServerStreaming(const upb_MethodDef* m);
+const upb_ServiceDef* upb_MethodDef_Service(const upb_MethodDef* m);
-typedef union {
- upb_Map* map;
- upb_Message* msg;
- upb_Array* array;
-} upb_MutableMessageValue;
+// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
+
+upb_MethodDef* _upb_MethodDef_At(const upb_MethodDef* m, int i);
+
+// Allocate and initialize an array of |n| method defs owned by |s|.
+upb_MethodDef* _upb_MethodDefs_New(
+ upb_DefBuilder* ctx, int n,
+ const google_protobuf_MethodDescriptorProto* const* protos, upb_ServiceDef* s);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_METHOD_DEF_H_ */
+
+// IWYU pragma: private, include "third_party/upb/upb/reflection/def.h"
+
+#ifndef UPB_REFLECTION_ONEOF_DEF_H_
+#define UPB_REFLECTION_ONEOF_DEF_H_
+
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const upb_MessageDef* upb_OneofDef_ContainingType(const upb_OneofDef* o);
+const upb_FieldDef* upb_OneofDef_Field(const upb_OneofDef* o, int i);
+int upb_OneofDef_FieldCount(const upb_OneofDef* o);
+const char* upb_OneofDef_FullName(const upb_OneofDef* o);
+bool upb_OneofDef_HasOptions(const upb_OneofDef* o);
+uint32_t upb_OneofDef_Index(const upb_OneofDef* o);
+bool upb_OneofDef_IsSynthetic(const upb_OneofDef* o);
+const upb_FieldDef* upb_OneofDef_LookupName(const upb_OneofDef* o,
+ const char* name);
+const upb_FieldDef* upb_OneofDef_LookupNameWithSize(const upb_OneofDef* o,
+ const char* name,
+ size_t size);
+const upb_FieldDef* upb_OneofDef_LookupNumber(const upb_OneofDef* o,
+ uint32_t num);
+const char* upb_OneofDef_Name(const upb_OneofDef* o);
+int upb_OneofDef_numfields(const upb_OneofDef* o);
+const google_protobuf_OneofOptions* upb_OneofDef_Options(const upb_OneofDef* o);
+
+// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
+
+upb_OneofDef* _upb_OneofDef_At(const upb_OneofDef* o, int i);
+bool _upb_OneofDef_Insert(upb_OneofDef* o, const upb_FieldDef* f,
+ const char* name, size_t size, upb_Arena* a);
+
+// Allocate and initialize an array of |n| oneof defs owned by |m|.
+upb_OneofDef* _upb_OneofDefs_New(
+ upb_DefBuilder* ctx, int n,
+ const google_protobuf_OneofDescriptorProto* const* protos, upb_MessageDef* m);
+
+size_t _upb_OneofDefs_Finalize(upb_DefBuilder* ctx, upb_MessageDef* m);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_ONEOF_DEF_H_ */
+
+// IWYU pragma: private, include "third_party/upb/upb/reflection/def.h"
+
+#ifndef UPB_REFLECTION_SERVICE_DEF_H_
+#define UPB_REFLECTION_SERVICE_DEF_H_
+
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const upb_FileDef* upb_ServiceDef_File(const upb_ServiceDef* s);
+const upb_MethodDef* upb_ServiceDef_FindMethodByName(const upb_ServiceDef* s,
+ const char* name);
+const char* upb_ServiceDef_FullName(const upb_ServiceDef* s);
+bool upb_ServiceDef_HasOptions(const upb_ServiceDef* s);
+int upb_ServiceDef_Index(const upb_ServiceDef* s);
+const upb_MethodDef* upb_ServiceDef_Method(const upb_ServiceDef* s, int i);
+int upb_ServiceDef_MethodCount(const upb_ServiceDef* s);
+const char* upb_ServiceDef_Name(const upb_ServiceDef* s);
+const google_protobuf_ServiceOptions* upb_ServiceDef_Options(const upb_ServiceDef* s);
+
+// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
+
+upb_ServiceDef* _upb_ServiceDef_At(const upb_ServiceDef* s, int i);
+
+// Allocate and initialize an array of |n| service defs.
+upb_ServiceDef* _upb_ServiceDefs_New(
+ upb_DefBuilder* ctx, int n,
+ const google_protobuf_ServiceDescriptorProto* const* protos);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_SERVICE_DEF_H_ */
+
+#endif /* UPB_REFLECTION_DEF_H_ */
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum { upb_JsonDecode_IgnoreUnknown = 1 };
+
+bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg,
+ const upb_MessageDef* m, const upb_DefPool* symtab,
+ int options, upb_Arena* arena, upb_Status* status);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_JSONDECODE_H_ */
+
+#ifndef UPB_INTERNAL_UNICODE_H_
+#define UPB_INTERNAL_UNICODE_H_
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Returns true iff a codepoint is the value for a high surrogate.
+UPB_INLINE bool upb_Unicode_IsHigh(uint32_t cp) {
+ return (cp >= 0xd800 && cp <= 0xdbff);
+}
+
+// Returns true iff a codepoint is the value for a low surrogate.
+UPB_INLINE bool upb_Unicode_IsLow(uint32_t cp) {
+ return (cp >= 0xdc00 && cp <= 0xdfff);
+}
+
+// Returns the high 16-bit surrogate value for a supplementary codepoint.
+// Does not sanity-check the input.
+UPB_INLINE uint16_t upb_Unicode_ToHigh(uint32_t cp) {
+ return (cp >> 10) + 0xd7c0;
+}
+
+// Returns the low 16-bit surrogate value for a supplementary codepoint.
+// Does not sanity-check the input.
+UPB_INLINE uint16_t upb_Unicode_ToLow(uint32_t cp) {
+ return (cp & 0x3ff) | 0xdc00;
+}
+
+// Returns the 32-bit value corresponding to a pair of 16-bit surrogates.
+// Does not sanity-check the input.
+UPB_INLINE uint32_t upb_Unicode_FromPair(uint32_t high, uint32_t low) {
+ return ((high & 0x3ff) << 10) + (low & 0x3ff) + 0x10000;
+}
+
+// Outputs a codepoint as UTF8.
+// Returns the number of bytes written (1-4 on success, 0 on error).
+// Does not sanity-check the input. Specifically does not check for surrogates.
+int upb_Unicode_ToUTF8(uint32_t cp, char* out);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_INTERNAL_UNICODE_H_ */
+
+#ifndef UPB_REFLECTION_MESSAGE_H_
+#define UPB_REFLECTION_MESSAGE_H_
+
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
upb_MessageValue upb_FieldDef_Default(const upb_FieldDef* f);
-/** upb_Message
- * *******************************************************************/
-
/* Creates a new message of the given type in the given arena. */
upb_Message* upb_Message_New(const upb_MessageDef* m, upb_Arena* a);
@@ -5418,130 +6803,18 @@
bool upb_Message_DiscardUnknown(upb_Message* msg, const upb_MessageDef* m,
int maxdepth);
-/** upb_Array *****************************************************************/
-
-/* Creates a new array on the given arena that holds elements of this type. */
-upb_Array* upb_Array_New(upb_Arena* a, upb_CType type);
-
-/* Returns the size of the array. */
-size_t upb_Array_Size(const upb_Array* arr);
-
-/* Returns the given element, which must be within the array's current size. */
-upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i);
-
-/* Sets the given element, which must be within the array's current size. */
-void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val);
-
-/* Appends an element to the array. Returns false on allocation failure. */
-bool upb_Array_Append(upb_Array* array, upb_MessageValue val, upb_Arena* arena);
-
-/* Moves elements within the array using memmove(). Like memmove(), the source
- * and destination elements may be overlapping. */
-void upb_Array_Move(upb_Array* array, size_t dst_idx, size_t src_idx,
- size_t count);
-
-/* Inserts one or more empty elements into the array. Existing elements are
- * shifted right. The new elements have undefined state and must be set with
- * `upb_Array_Set()`.
- * REQUIRES: `i <= upb_Array_Size(arr)` */
-bool upb_Array_Insert(upb_Array* array, size_t i, size_t count,
- upb_Arena* arena);
-
-/* Deletes one or more elements from the array. Existing elements are shifted
- * left.
- * REQUIRES: `i + count <= upb_Array_Size(arr)` */
-void upb_Array_Delete(upb_Array* array, size_t i, size_t count);
-
-/* Changes the size of a vector. New elements are initialized to empty/0.
- * Returns false on allocation failure. */
-bool upb_Array_Resize(upb_Array* array, size_t size, upb_Arena* arena);
-
-/** upb_Map *******************************************************************/
-
-/* Creates a new map on the given arena with the given key/value size. */
-upb_Map* upb_Map_New(upb_Arena* a, upb_CType key_type, upb_CType value_type);
-
-/* Returns the number of entries in the map. */
-size_t upb_Map_Size(const upb_Map* map);
-
-/* Stores a value for the given key into |*val| (or the zero value if the key is
- * not present). Returns whether the key was present. The |val| pointer may be
- * NULL, in which case the function tests whether the given key is present. */
-bool upb_Map_Get(const upb_Map* map, upb_MessageValue key,
- upb_MessageValue* val);
-
-/* Removes all entries in the map. */
-void upb_Map_Clear(upb_Map* map);
-
-/* Sets the given key to the given value. Returns true if this was a new key in
- * the map, or false if an existing key was replaced. */
-bool upb_Map_Set(upb_Map* map, upb_MessageValue key, upb_MessageValue val,
- upb_Arena* arena);
-
-/* Deletes this key from the table. Returns true if the key was present. */
-bool upb_Map_Delete(upb_Map* map, upb_MessageValue key);
-
-/* Map iteration:
- *
- * size_t iter = kUpb_Map_Begin;
- * while (upb_MapIterator_Next(map, &iter)) {
- * upb_MessageValue key = upb_MapIterator_Key(map, iter);
- * upb_MessageValue val = upb_MapIterator_Value(map, iter);
- *
- * // If mutating is desired.
- * upb_MapIterator_SetValue(map, iter, value2);
- * }
- */
-
-/* Advances to the next entry. Returns false if no more entries are present. */
-bool upb_MapIterator_Next(const upb_Map* map, size_t* iter);
-
-/* Returns true if the iterator still points to a valid entry, or false if the
- * iterator is past the last element. It is an error to call this function with
- * kUpb_Map_Begin (you must call next() at least once first). */
-bool upb_MapIterator_Done(const upb_Map* map, size_t iter);
-
-/* Returns the key and value for this entry of the map. */
-upb_MessageValue upb_MapIterator_Key(const upb_Map* map, size_t iter);
-upb_MessageValue upb_MapIterator_Value(const upb_Map* map, size_t iter);
-
-/* Sets the value for this entry. The iterator must not be done, and the
- * iterator must not have been initialized const. */
-void upb_MapIterator_SetValue(upb_Map* map, size_t iter,
- upb_MessageValue value);
-
#ifdef __cplusplus
} /* extern "C" */
#endif
-#endif /* UPB_REFLECTION_H_ */
+#endif /* UPB_REFLECTION_MESSAGE_H_ */
-/** upb/json_decode.h ************************************************************/
-#ifndef UPB_JSONDECODE_H_
-#define UPB_JSONDECODE_H_
+#ifndef UPB_JSON_ENCODE_H_
+#define UPB_JSON_ENCODE_H_
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-enum { upb_JsonDecode_IgnoreUnknown = 1 };
-
-bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg,
- const upb_MessageDef* m, const upb_DefPool* symtab,
- int options, upb_Arena* arena, upb_Status* status);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* UPB_JSONDECODE_H_ */
-
-/** upb/json_encode.h ************************************************************/
-#ifndef UPB_JSONENCODE_H_
-#define UPB_JSONENCODE_H_
-
+// Must be last.
#ifdef __cplusplus
extern "C" {
@@ -5549,11 +6822,14 @@
enum {
/* When set, emits 0/default values. TODO(haberman): proto3 only? */
- upb_JsonEncode_EmitDefaults = 1,
+ upb_JsonEncode_EmitDefaults = 1 << 0,
- /* When set, use normal (snake_caes) field names instead of JSON (camelCase)
+ /* When set, use normal (snake_case) field names instead of JSON (camelCase)
names. */
- upb_JsonEncode_UseProtoNames = 2
+ upb_JsonEncode_UseProtoNames = 1 << 1,
+
+ /* When set, emits enums as their integer values instead of as their names. */
+ upb_JsonEncode_FormatEnumsAsIntegers = 1 << 2
};
/* Encodes the given |msg| to JSON format. The message's reflection is given in
@@ -5572,9 +6848,401 @@
} /* extern "C" */
#endif
+
#endif /* UPB_JSONENCODE_H_ */
-/** upb/port_undef.inc ************************************************************/
+#ifndef UPB_INTERNAL_ENCODE_H_
+#define UPB_INTERNAL_ENCODE_H_
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Encodes a float or double that is round-trippable, but as short as possible.
+// These routines are not fully optimal (not guaranteed to be shortest), but are
+// short-ish and match the implementation that has been used in protobuf since
+// the beginning.
+//
+// The given buffer size must be at least kUpb_RoundTripBufferSize.
+enum { kUpb_RoundTripBufferSize = 32 };
+void _upb_EncodeRoundTripDouble(double val, char* buf, size_t size);
+void _upb_EncodeRoundTripFloat(float val, char* buf, size_t size);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_INTERNAL_ENCODE_H_ */
+
+#ifndef UPB_INTERNAL_VSNPRINTF_COMPAT_H_
+#define UPB_INTERNAL_VSNPRINTF_COMPAT_H_
+
+#include <stdio.h>
+
+// Must be last.
+
+UPB_INLINE int _upb_vsnprintf(char* buf, size_t size, const char* fmt,
+ va_list ap) {
+#if defined(__MINGW64__) || defined(__MINGW32__) || defined(_MSC_VER)
+ // The msvc runtime has a non-conforming vsnprintf() that requires the
+ // following compatibility code to become conformant.
+ int n = -1;
+ if (size != 0) n = _vsnprintf_s(buf, size, _TRUNCATE, fmt, ap);
+ if (n == -1) n = _vscprintf(fmt, ap);
+ return n;
+#else
+ return vsnprintf(buf, size, fmt, ap);
+#endif
+}
+
+
+#endif // UPB_INTERNAL_VSNPRINTF_COMPAT_H_
+
+#ifndef UPB_MINI_TABLE_H_
+#define UPB_MINI_TABLE_H_
+
+
+// Must be last.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const upb_MiniTable_Field* upb_MiniTable_FindFieldByNumber(
+ const upb_MiniTable* table, uint32_t number);
+
+UPB_INLINE const upb_MiniTable* upb_MiniTable_GetSubMessageTable(
+ const upb_MiniTable* mini_table, const upb_MiniTable_Field* field) {
+ return mini_table->subs[field->submsg_index].submsg;
+}
+
+UPB_INLINE const upb_MiniTable_Enum* upb_MiniTable_GetSubEnumTable(
+ const upb_MiniTable* mini_table, const upb_MiniTable_Field* field) {
+ return mini_table->subs[field->submsg_index].subenum;
+}
+
+/** upb_MtDataEncoder *********************************************************/
+
+// Functions to encode a string in a format that can be loaded by
+// upb_MiniTable_Build().
+
+typedef enum {
+ kUpb_MessageModifier_ValidateUtf8 = 1 << 0,
+ kUpb_MessageModifier_DefaultIsPacked = 1 << 1,
+ kUpb_MessageModifier_IsExtendable = 1 << 2,
+} kUpb_MessageModifier;
+
+typedef enum {
+ kUpb_FieldModifier_IsRepeated = 1 << 0,
+ kUpb_FieldModifier_IsPacked = 1 << 1,
+ kUpb_FieldModifier_IsClosedEnum = 1 << 2,
+ kUpb_FieldModifier_IsProto3Singular = 1 << 3,
+ kUpb_FieldModifier_IsRequired = 1 << 4,
+} kUpb_FieldModifier;
+
+typedef struct {
+ char* end; // Limit of the buffer passed as a parameter.
+ // Aliased to internal-only members in .cc.
+ char internal[32];
+} upb_MtDataEncoder;
+
+// If the input buffer has at least this many bytes available, the encoder call
+// is guaranteed to succeed (as long as field number order is maintained).
+#define kUpb_MtDataEncoder_MinSize 16
+
+// Encodes field/oneof information for a given message. The sequence of calls
+// should look like:
+//
+// upb_MtDataEncoder e;
+// char buf[256];
+// char* ptr = buf;
+// e.end = ptr + sizeof(buf);
+// unit64_t msg_mod = ...; // bitwise & of kUpb_MessageModifiers or zero
+// ptr = upb_MtDataEncoder_StartMessage(&e, ptr, msg_mod);
+// // Fields *must* be in field number order.
+// ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+// ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+// ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+//
+// // If oneofs are present. Oneofs must be encoded after regular fields.
+// ptr = upb_MiniTable_StartOneof(&e, ptr)
+// ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+// ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+//
+// ptr = upb_MiniTable_StartOneof(&e, ptr);
+// ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+// ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+//
+// Oneofs must be encoded after all regular fields.
+char* upb_MtDataEncoder_StartMessage(upb_MtDataEncoder* e, char* ptr,
+ uint64_t msg_mod);
+char* upb_MtDataEncoder_PutField(upb_MtDataEncoder* e, char* ptr,
+ upb_FieldType type, uint32_t field_num,
+ uint64_t field_mod);
+char* upb_MtDataEncoder_StartOneof(upb_MtDataEncoder* e, char* ptr);
+char* upb_MtDataEncoder_PutOneofField(upb_MtDataEncoder* e, char* ptr,
+ uint32_t field_num);
+
+// Encodes the set of values for a given enum. The values must be given in
+// order (after casting to uint32_t), and repeats are not allowed.
+void upb_MtDataEncoder_StartEnum(upb_MtDataEncoder* e);
+char* upb_MtDataEncoder_PutEnumValue(upb_MtDataEncoder* e, char* ptr,
+ uint32_t val);
+char* upb_MtDataEncoder_EndEnum(upb_MtDataEncoder* e, char* ptr);
+
+/** upb_MiniTable *************************************************************/
+
+typedef enum {
+ kUpb_MiniTablePlatform_32Bit,
+ kUpb_MiniTablePlatform_64Bit,
+ kUpb_MiniTablePlatform_Native =
+ UPB_SIZE(kUpb_MiniTablePlatform_32Bit, kUpb_MiniTablePlatform_64Bit),
+} upb_MiniTablePlatform;
+
+// Builds a mini table from the data encoded in the buffer [data, len]. If any
+// errors occur, returns NULL and sets a status message. In the success case,
+// the caller must call upb_MiniTable_SetSub*() for all message or proto2 enum
+// fields to link the table to the appropriate sub-tables.
+upb_MiniTable* upb_MiniTable_Build(const char* data, size_t len,
+ upb_MiniTablePlatform platform,
+ upb_Arena* arena, upb_Status* status);
+
+// Links a sub-message field to a MiniTable for that sub-message. If a
+// sub-message field is not linked, it will be treated as an unknown field
+// during parsing, and setting the field will not be allowed. It is possible
+// to link the message field later, at which point it will no longer be treated
+// as unknown. However there is no synchronization for this operation, which
+// means parallel mutation requires external synchronization.
+void upb_MiniTable_SetSubMessage(upb_MiniTable* table,
+ upb_MiniTable_Field* field,
+ const upb_MiniTable* sub);
+
+// Links an enum field to a MiniTable for that enum. All enum fields must
+// be linked prior to parsing.
+void upb_MiniTable_SetSubEnum(upb_MiniTable* table, upb_MiniTable_Field* field,
+ const upb_MiniTable_Enum* sub);
+
+const char* upb_MiniTable_BuildExtension(const char* data, size_t len,
+ upb_MiniTable_Extension* ext,
+ const upb_MiniTable* extendee,
+ upb_MiniTable_Sub sub,
+ upb_Status* status);
+
+// Special-case functions for MessageSet layout and map entries.
+upb_MiniTable* upb_MiniTable_BuildMessageSet(upb_MiniTablePlatform platform,
+ upb_Arena* arena);
+upb_MiniTable* upb_MiniTable_BuildMapEntry(upb_FieldType key_type,
+ upb_FieldType value_type,
+ bool value_is_proto3_enum,
+ upb_MiniTablePlatform platform,
+ upb_Arena* arena);
+
+upb_MiniTable_Enum* upb_MiniTable_BuildEnum(const char* data, size_t len,
+ upb_Arena* arena,
+ upb_Status* status);
+
+// Like upb_MiniTable_Build(), but the user provides a buffer of layout data so
+// it can be reused from call to call, avoiding repeated realloc()/free().
+//
+// The caller owns `*buf` both before and after the call, and must free() it
+// when it is no longer in use. The function will realloc() `*buf` as
+// necessary, updating `*size` accordingly.
+upb_MiniTable* upb_MiniTable_BuildWithBuf(const char* data, size_t len,
+ upb_MiniTablePlatform platform,
+ upb_Arena* arena, void** buf,
+ size_t* buf_size, upb_Status* status);
+
+// For testing only.
+char upb_ToBase92(int8_t ch);
+char upb_FromBase92(uint8_t ch);
+bool upb_IsTypePackable(upb_FieldType type);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_MINI_TABLE_H_ */
+
+#ifndef UPB_REFLECTION_DEF_BUILDER_H_
+#define UPB_REFLECTION_DEF_BUILDER_H_
+
+
+// Must be last.
+
+// We want to copy the options verbatim into the destination options proto.
+// We use serialize+parse as our deep copy.
+#define UBP_DEF_SET_OPTIONS(target, desc_type, options_type, proto) \
+ if (google_protobuf_##desc_type##_has_options(proto)) { \
+ size_t size; \
+ char* pb = google_protobuf_##options_type##_serialize( \
+ google_protobuf_##desc_type##_options(proto), ctx->tmp_arena, &size); \
+ if (!pb) _upb_DefBuilder_OomErr(ctx); \
+ target = \
+ google_protobuf_##options_type##_parse(pb, size, _upb_DefBuilder_Arena(ctx)); \
+ if (!target) _upb_DefBuilder_OomErr(ctx); \
+ } else { \
+ target = (const google_protobuf_##options_type*)kUpbDefOptDefault; \
+ }
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct upb_DefBuilder {
+ upb_DefPool* symtab;
+ upb_FileDef* file; // File we are building.
+ upb_Arena* arena; // Allocate defs here.
+ upb_Arena* tmp_arena; // For temporary allocations.
+ upb_Status* status; // Record errors here.
+ const upb_MiniTable_File* layout; // NULL if we should build layouts.
+ int enum_count; // Count of enums built so far.
+ int msg_count; // Count of messages built so far.
+ int ext_count; // Count of extensions built so far.
+ jmp_buf err; // longjmp() on error.
+};
+
+extern const char* kUpbDefOptDefault;
+
+// ctx->status has already been set elsewhere so just fail/longjmp()
+UPB_NORETURN void _upb_DefBuilder_FailJmp(upb_DefBuilder* ctx);
+
+UPB_NORETURN void _upb_DefBuilder_Errf(upb_DefBuilder* ctx, const char* fmt,
+ ...) UPB_PRINTF(2, 3);
+UPB_NORETURN void _upb_DefBuilder_OomErr(upb_DefBuilder* ctx);
+
+const char* _upb_DefBuilder_MakeFullName(upb_DefBuilder* ctx,
+ const char* prefix,
+ upb_StringView name);
+
+// Given a symbol and the base symbol inside which it is defined,
+// find the symbol's definition.
+const void* _upb_DefBuilder_ResolveAny(upb_DefBuilder* ctx,
+ const char* from_name_dbg,
+ const char* base, upb_StringView sym,
+ upb_deftype_t* type);
+
+const void* _upb_DefBuilder_Resolve(upb_DefBuilder* ctx,
+ const char* from_name_dbg, const char* base,
+ upb_StringView sym, upb_deftype_t type);
+
+char _upb_DefBuilder_ParseEscape(upb_DefBuilder* ctx, const upb_FieldDef* f,
+ const char** src, const char* end);
+
+const char* _upb_DefBuilder_FullToShort(const char* fullname);
+
+UPB_INLINE void* _upb_DefBuilder_Alloc(upb_DefBuilder* ctx, size_t bytes) {
+ if (bytes == 0) return NULL;
+ void* ret = upb_Arena_Malloc(ctx->arena, bytes);
+ if (!ret) _upb_DefBuilder_OomErr(ctx);
+ return ret;
+}
+
+// Adds a symbol |v| to the symtab, which must be a def pointer previously
+// packed with pack_def(). The def's pointer to upb_FileDef* must be set before
+// adding, so we know which entries to remove if building this file fails.
+UPB_INLINE void _upb_DefBuilder_Add(upb_DefBuilder* ctx, const char* name,
+ upb_value v) {
+ upb_StringView sym = {.data = name, .size = strlen(name)};
+ bool ok = _upb_DefPool_InsertSym(ctx->symtab, sym, v, ctx->status);
+ if (!ok) _upb_DefBuilder_FailJmp(ctx);
+}
+
+UPB_INLINE upb_Arena* _upb_DefBuilder_Arena(const upb_DefBuilder* ctx) {
+ return ctx->arena;
+}
+
+UPB_INLINE upb_FileDef* _upb_DefBuilder_File(const upb_DefBuilder* ctx) {
+ return ctx->file;
+}
+
+// This version of CheckIdent() is only called by other, faster versions after
+// they detect a parsing error.
+void _upb_DefBuilder_CheckIdentSlow(upb_DefBuilder* ctx, upb_StringView name,
+ bool full);
+
+// Verify a relative identifier string. The loop is branchless for speed.
+UPB_INLINE void _upb_DefBuilder_CheckIdentNotFull(upb_DefBuilder* ctx,
+ upb_StringView name) {
+ bool good = name.size > 0;
+
+ for (size_t i = 0; i < name.size; i++) {
+ const char c = name.data[i];
+ const char d = c | 0x20; // force lowercase
+ const bool is_alpha = (('a' <= d) & (d <= 'z')) | (c == '_');
+ const bool is_numer = ('0' <= c) & (c <= '9') & (i != 0);
+
+ good &= is_alpha | is_numer;
+ }
+
+ if (!good) _upb_DefBuilder_CheckIdentSlow(ctx, name, false);
+}
+
+// Verify a full identifier string. This is slightly more complicated than
+// verifying a relative identifier string because we must track '.' chars.
+UPB_INLINE void _upb_DefBuilder_CheckIdentFull(upb_DefBuilder* ctx,
+ upb_StringView name) {
+ bool good = name.size > 0;
+ bool start = true;
+
+ for (size_t i = 0; i < name.size; i++) {
+ const char c = name.data[i];
+ const char d = c | 0x20; // force lowercase
+ const bool is_alpha = (('a' <= d) & (d <= 'z')) | (c == '_');
+ const bool is_numer = ('0' <= c) & (c <= '9') & !start;
+ const bool is_dot = (c == '.') & !start;
+
+ good &= is_alpha | is_numer | is_dot;
+ start = is_dot;
+ }
+
+ if (!good) _upb_DefBuilder_CheckIdentSlow(ctx, name, true);
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_DEF_BUILDER_H_ */
+
+#ifndef UPB_REFLECTION_DESC_STATE_H_
+#define UPB_REFLECTION_DESC_STATE_H_
+
+
+// Must be last.
+
+// Manages the storage for mini descriptor strings as they are being encoded.
+// TODO(b/234740652): Move some of this state directly into the encoder, maybe.
+typedef struct {
+ upb_MtDataEncoder e;
+ size_t bufsize;
+ char* buf;
+ char* ptr;
+} upb_DescState;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+UPB_INLINE void _upb_DescState_Init(upb_DescState* d) {
+ d->bufsize = kUpb_MtDataEncoder_MinSize * 2;
+ d->buf = NULL;
+ d->ptr = NULL;
+}
+
+bool _upb_DescState_Grow(upb_DescState* d, upb_Arena* a);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* UPB_REFLECTION_DESC_STATE_H_ */
+
/* See port_def.inc. This should #undef all macros #defined there. */
#undef UPB_SIZE
@@ -5587,6 +7255,7 @@
#undef UPB_ALIGN_DOWN
#undef UPB_ALIGN_MALLOC
#undef UPB_ALIGN_OF
+#undef UPB_MALLOC_ALIGN
#undef UPB_LIKELY
#undef UPB_UNLIKELY
#undef UPB_FORCEINLINE
@@ -5610,3 +7279,5 @@
#undef UPB_UNPOISON_MEMORY_REGION
#undef UPB_ASAN
#undef UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3
+#undef UPB_DEPRECATED
+#undef UPB_GNUC_MIN
