Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/php/ext/google/protobuf/upb.h

 // Amalgamated source file
 /*
 ** Defs are upb's internal representation of the constructs that can appear
 ** in a .proto file:
 **
 ** - upb::MessageDef (upb_msgdef): describes a "message" construct.
 ** - upb::FieldDef (upb_fielddef): describes a message field.
-** - upb::FileDef (upb_filedef): describes a .proto file and its defs.
 ** - upb::EnumDef (upb_enumdef): describes an enum.
 ** - upb::OneofDef (upb_oneofdef): describes a oneof.
 ** - upb::Def (upb_def): base class of all the others.
 **
 ** TODO: definitions of services.
 **
 ** Like upb_refcounted objects, defs are mutable only until frozen, and are
 ** only thread-safe once frozen.
 **
 ** This is a mixed C/C++ interface that offers a full API to both languages.
@@ skipping 36 matching lines @@
 ** store pointers or integers of at least 32 bits (upb isn't really useful on
 ** systems where sizeof(void*) < 4).
 **
 ** The table must be homogenous (all values of the same type).  In debug
 ** mode, we check this on insert and lookup.
 */
 
 #ifndef UPB_TABLE_H_
 #define UPB_TABLE_H_
 
-// php.h intentionally defined NDEBUG. We have to define this macro in order to
-// be used together with php.h
-#ifndef NDEBUG
-#define NDEBUG
-#endif
-
+#include <assert.h>
 #include <stdint.h>
 #include <string.h>
 /*
 ** This file contains shared definitions that are widely used across upb.
 **
 ** This is a mixed C/C++ interface that offers a full API to both languages.
 ** See the top-level README for more information.
 */
 
 #ifndef UPB_H_
 #define UPB_H_
 
 #include <assert.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stddef.h>
 
-#ifdef __cplusplus
-namespace upb {
-class Allocator;
-class Arena;
-class Environment;
-class ErrorSpace;
-class Status;
-template <int N> class InlinedArena;
-template <int N> class InlinedEnvironment;
-}
-#endif
-
 /* UPB_INLINE: inline if possible, emit standalone code if required. */
 #ifdef __cplusplus
 #define UPB_INLINE inline
 #elif defined (__GNUC__)
 #define UPB_INLINE static __inline__
 #else
 #define UPB_INLINE static
 #endif
 
 /* Define UPB_BIG_ENDIAN manually if you're on big endian and your compiler
@@ skipping 47 matching lines @@
 #define UPB_DISALLOW_COPY_AND_ASSIGN(class_name) \
   class_name(const class_name&) = delete; \
   void operator=(const class_name&) = delete;
 #define UPB_DISALLOW_POD_OPS(class_name, full_class_name) \
   class_name() = delete; \
   ~class_name() = delete; \
   UPB_DISALLOW_COPY_AND_ASSIGN(class_name)
 #define UPB_ASSERT_STDLAYOUT(type) \
   static_assert(std::is_standard_layout<type>::value, \
                 #type " must be standard layout");
-#define UPB_FINAL final
 #else  /* !defined(UPB_CXX11) */
 #define UPB_DISALLOW_COPY_AND_ASSIGN(class_name) \
   class_name(const class_name&); \
   void operator=(const class_name&);
 #define UPB_DISALLOW_POD_OPS(class_name, full_class_name) \
   class_name(); \
   ~class_name(); \
   UPB_DISALLOW_COPY_AND_ASSIGN(class_name)
 #define UPB_ASSERT_STDLAYOUT(type)
-#define UPB_FINAL
 #endif
 
 /* UPB_DECLARE_TYPE()
  * UPB_DECLARE_DERIVED_TYPE()
  * UPB_DECLARE_DERIVED_TYPE2()
  *
  * Macros for declaring C and C++ types both, including inheritance.
  * The inheritance doesn't use real C++ inheritance, to stay compatible with C.
  *
  * These macros also provide upcasts:
@@ skipping 18 matching lines @@
 #define UPB_PRIVATE_FOR_CPP private:
 #define UPB_DECLARE_TYPE(cppname, cname) typedef cppname cname;
 
 #define UPB_DECLARE_DERIVED_TYPE(cppname, cppbase, cname, cbase)  \
   UPB_DECLARE_TYPE(cppname, cname)                                \
   UPB_C_UPCASTS(cname, cbase)                                     \
   namespace upb {                                                 \
   template <>                                                     \
   class Pointer<cppname> : public PointerBase<cppname, cppbase> { \
    public:                                                        \
-    explicit Pointer(cppname* ptr)                                \
-        : PointerBase<cppname, cppbase>(ptr) {}                   \
+    explicit Pointer(cppname* ptr) : PointerBase(ptr) {}          \
   };                                                              \
   template <>                                                     \
   class Pointer<const cppname>                                    \
       : public PointerBase<const cppname, const cppbase> {        \
    public:                                                        \
-    explicit Pointer(const cppname* ptr)                          \
-        : PointerBase<const cppname, const cppbase>(ptr) {}       \
+    explicit Pointer(const cppname* ptr) : PointerBase(ptr) {}    \
   };                                                              \
   }
 
 #define UPB_DECLARE_DERIVED_TYPE2(cppname, cppbase, cppbase2, cname, cbase,  \
                                   cbase2)                                    \
   UPB_DECLARE_TYPE(cppname, cname)                                           \
   UPB_C_UPCASTS2(cname, cbase, cbase2)                                       \
   namespace upb {                                                            \
   template <>                                                                \
   class Pointer<cppname> : public PointerBase2<cppname, cppbase, cppbase2> { \
    public:                                                                   \
-    explicit Pointer(cppname* ptr)                                           \
-        : PointerBase2<cppname, cppbase, cppbase2>(ptr) {}                   \
+    explicit Pointer(cppname* ptr) : PointerBase2(ptr) {}                    \
   };                                                                         \
   template <>                                                                \
   class Pointer<const cppname>                                               \
       : public PointerBase2<const cppname, const cppbase, const cppbase2> {  \
    public:                                                                   \
-    explicit Pointer(const cppname* ptr)                                     \
-        : PointerBase2<const cppname, const cppbase, const cppbase2>(ptr) {} \
+    explicit Pointer(const cppname* ptr) : PointerBase2(ptr) {}              \
   };                                                                         \
   }
 
 #else  /* !defined(__cplusplus) */
 
 #define UPB_BEGIN_EXTERN_C
 #define UPB_END_EXTERN_C
 #define UPB_PRIVATE_FOR_CPP
 #define UPB_DECLARE_TYPE(cppname, cname) \
   struct cname;                          \
   typedef struct cname cname;
 #define UPB_DECLARE_DERIVED_TYPE(cppname, cppbase, cname, cbase) \
   UPB_DECLARE_TYPE(cppname, cname)                               \
   UPB_C_UPCASTS(cname, cbase)
 #define UPB_DECLARE_DERIVED_TYPE2(cppname, cppbase, cppbase2,    \
                                   cname, cbase, cbase2)          \
   UPB_DECLARE_TYPE(cppname, cname)                               \
   UPB_C_UPCASTS2(cname, cbase, cbase2)
 
 #endif  /* defined(__cplusplus) */
 
 #define UPB_MAX(x, y) ((x) > (y) ? (x) : (y))
 #define UPB_MIN(x, y) ((x) < (y) ? (x) : (y))
 
 #define UPB_UNUSED(var) (void)var
 
-/* UPB_ASSERT(): in release mode, we use the expression without letting it be
- * evaluated.  This prevents "unused variable" warnings. */
-#ifdef NDEBUG
-#define UPB_ASSERT(expr) do {} while (false && (expr))
-#else
-#define UPB_ASSERT(expr) assert(expr)
-#endif
-
-/* UPB_ASSERT_DEBUGVAR(): assert that uses functions or variables that only
- * exist in debug mode.  This turns into regular assert. */
-#define UPB_ASSERT_DEBUGVAR(expr) assert(expr)
+/* For asserting something about a variable when the variable is not used for
+ * anything else.  This prevents "unused variable" warnings when compiling in
+ * debug mode. */
+#define UPB_ASSERT_VAR(var, predicate) UPB_UNUSED(var); assert(predicate)
 
 /* Generic function type. */
 typedef void upb_func();
 
-
 /* C++ Casts ******************************************************************/
 
 #ifdef __cplusplus
 
 namespace upb {
 
 template <class T> class Pointer;
 
 /* Casts to a subclass.  The caller must know that cast is correct; an
  * incorrect cast will throw an assertion failure in debug mode.
@@ skipping 57 matching lines @@
  public:
   explicit PointerBase2(T* ptr) : PointerBase<T, Base>(ptr) {}
   operator Base2*() { return Pointer<Base>(*this); }
 };
 
 }
 
 #endif
 
 
-/* upb::ErrorSpace ************************************************************/
-
-/* A upb::ErrorSpace represents some domain of possible error values.  This lets
- * upb::Status attach specific error codes to operations, like POSIX/C errno,
- * Win32 error codes, etc.  Clients who want to know the very specific error
- * code can check the error space and then know the type of the integer code.
- *
- * NOTE: upb::ErrorSpace is currently not used and should be considered
- * experimental.  It is important primarily in cases where upb is performing
- * I/O, but upb doesn't currently have any components that do this. */
+/* upb::reffed_ptr ************************************************************/
+
+#ifdef __cplusplus
+
+#include <algorithm>  /* For std::swap(). */
+
+namespace upb {
+
+/* Provides RAII semantics for upb refcounted objects.  Each reffed_ptr owns a
+ * ref on whatever object it points to (if any). */
+template <class T> class reffed_ptr {
+ public:
+  reffed_ptr() : ptr_(NULL) {}
+
+  /* If ref_donor is NULL, takes a new ref, otherwise adopts from ref_donor. */
+  template <class U>
+  reffed_ptr(U* val, const void* ref_donor = NULL)
+      : ptr_(upb::upcast(val)) {
+    if (ref_donor) {
+      assert(ptr_);
+      ptr_->DonateRef(ref_donor, this);
+    } else if (ptr_) {
+      ptr_->Ref(this);
+    }
+  }
+
+  template <class U>
+  reffed_ptr(const reffed_ptr<U>& other)
+      : ptr_(upb::upcast(other.get())) {
+    if (ptr_) ptr_->Ref(this);
+  }
+
+  ~reffed_ptr() { if (ptr_) ptr_->Unref(this); }
+
+  template <class U>
+  reffed_ptr& operator=(const reffed_ptr<U>& other) {
+    reset(other.get());
+    return *this;
+  }
+
+  reffed_ptr& operator=(const reffed_ptr& other) {
+    reset(other.get());
+    return *this;
+  }
+
+  /* TODO(haberman): add C++11 move construction/assignment for greater
+   * efficiency. */
+
+  void swap(reffed_ptr& other) {
+    if (ptr_ == other.ptr_) {
+      return;
+    }
+
+    if (ptr_) ptr_->DonateRef(this, &other);
+    if (other.ptr_) other.ptr_->DonateRef(&other, this);
+    std::swap(ptr_, other.ptr_);
+  }
+
+  T& operator*() const {
+    assert(ptr_);
+    return *ptr_;
+  }
+
+  T* operator->() const {
+    assert(ptr_);
+    return ptr_;
+  }
+
+  T* get() const { return ptr_; }
+
+  /* If ref_donor is NULL, takes a new ref, otherwise adopts from ref_donor. */
+  template <class U>
+  void reset(U* ptr = NULL, const void* ref_donor = NULL) {
+    reffed_ptr(ptr, ref_donor).swap(*this);
+  }
+
+  template <class U>
+  reffed_ptr<U> down_cast() {
+    return reffed_ptr<U>(upb::down_cast<U*>(get()));
+  }
+
+  template <class U>
+  reffed_ptr<U> dyn_cast() {
+    return reffed_ptr<U>(upb::dyn_cast<U*>(get()));
+  }
+
+  /* Plain release() is unsafe; if we were the only owner, it would leak the
+   * object.  Instead we provide this: */
+  T* ReleaseTo(const void* new_owner) {
+    T* ret = NULL;
+    ptr_->DonateRef(this, new_owner);
+    std::swap(ret, ptr_);
+    return ret;
+  }
+
+ private:
+  T* ptr_;
+};
+
+}  /* namespace upb */
+
+#endif  /* __cplusplus */
+
+
+/* upb::Status ****************************************************************/
+
+#ifdef __cplusplus
+namespace upb {
+class ErrorSpace;
+class Status;
+}
+#endif
 
 UPB_DECLARE_TYPE(upb::ErrorSpace, upb_errorspace)
+UPB_DECLARE_TYPE(upb::Status, upb_status)
+
+/* The maximum length of an error message before it will get truncated. */
+#define UPB_STATUS_MAX_MESSAGE 128
+
+/* An error callback function is used to report errors from some component.
+ * The function can return "true" to indicate that the component should try
+ * to recover and proceed, but this is not always possible. */
+typedef bool upb_errcb_t(void *closure, const upb_status* status);
 
 #ifdef __cplusplus
 class upb::ErrorSpace {
 #else
 struct upb_errorspace {
 #endif
   const char *name;
+  /* Should the error message in the status object according to this code. */
+  void (*set_message)(upb_status* status, int code);
 };
 
-
-/* upb::Status ****************************************************************/
-
-/* upb::Status represents a success or failure status and error message.
+#ifdef __cplusplus
+
+/* Object representing a success or failure status.
  * It owns no resources and allocates no memory, so it should work
  * even in OOM situations. */
-UPB_DECLARE_TYPE(upb::Status, upb_status)
-
-/* The maximum length of an error message before it will get truncated. */
-#define UPB_STATUS_MAX_MESSAGE 128
-
-UPB_BEGIN_EXTERN_C
-
+
+class upb::Status {
+ public:
+  Status();
+
+  /* Returns true if there is no error. */
+  bool ok() const;
+
+  /* Optional error space and code, useful if the caller wants to
+   * programmatically check the specific kind of error. */
+  ErrorSpace* error_space();
+  int code() const;
+
+  const char *error_message() const;
+
+  /* The error message will be truncated if it is longer than
+   * UPB_STATUS_MAX_MESSAGE-4. */
+  void SetErrorMessage(const char* msg);
+  void SetFormattedErrorMessage(const char* fmt, ...);
+
+  /* If there is no error message already, this will use the ErrorSpace to
+   * populate the error message for this code.  The caller can still call
+   * SetErrorMessage() to give a more specific message. */
+  void SetErrorCode(ErrorSpace* space, int code);
+
+  /* Resets the status to a successful state with no message. */
+  void Clear();
+
+  void CopyFrom(const Status& other);
+
+ private:
+  UPB_DISALLOW_COPY_AND_ASSIGN(Status)
+#else
+struct upb_status {
+#endif
+  bool ok_;
+
+  /* Specific status code defined by some error space (optional). */
+  int code_;
+  upb_errorspace *error_space_;
+
+  /* Error message; NULL-terminated. */
+  char msg[UPB_STATUS_MAX_MESSAGE];
+};
+
+#define UPB_STATUS_INIT {true, 0, NULL, {0}}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The returned string is invalidated by any other call into the status. */
 const char *upb_status_errmsg(const upb_status *status);
 bool upb_ok(const upb_status *status);
 upb_errorspace *upb_status_errspace(const upb_status *status);
 int upb_status_errcode(const upb_status *status);
 
 /* Any of the functions that write to a status object allow status to be NULL,
  * to support use cases where the function's caller does not care about the
  * status message. */
 void upb_status_clear(upb_status *status);
 void upb_status_seterrmsg(upb_status *status, const char *msg);
 void upb_status_seterrf(upb_status *status, const char *fmt, ...);
 void upb_status_vseterrf(upb_status *status, const char *fmt, va_list args);
+void upb_status_seterrcode(upb_status *status, upb_errorspace *space, int code);
 void upb_status_copy(upb_status *to, const upb_status *from);
 
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-
-class upb::Status {
- public:
-  Status() { upb_status_clear(this); }
-
-  /* Returns true if there is no error. */
-  bool ok() const { return upb_ok(this); }
-
-  /* Optional error space and code, useful if the caller wants to
-   * programmatically check the specific kind of error. */
-  ErrorSpace* error_space() { return upb_status_errspace(this); }
-  int error_code() const { return upb_status_errcode(this); }
-
-  /* The returned string is invalidated by any other call into the status. */
-  const char *error_message() const { return upb_status_errmsg(this); }
-
-  /* The error message will be truncated if it is longer than
-   * UPB_STATUS_MAX_MESSAGE-4. */
-  void SetErrorMessage(const char* msg) { upb_status_seterrmsg(this, msg); }
-  void SetFormattedErrorMessage(const char* fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    upb_status_vseterrf(this, fmt, args);
-    va_end(args);
-  }
-
-  /* Resets the status to a successful state with no message. */
-  void Clear() { upb_status_clear(this); }
-
-  void CopyFrom(const Status& other) { upb_status_copy(this, &other); }
-
- private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(Status)
-#else
-struct upb_status {
-#endif
-  bool ok_;
-
-  /* Specific status code defined by some error space (optional). */
-  int code_;
-  upb_errorspace *error_space_;
-
-  /* TODO(haberman): add file/line of error? */
-
-  /* Error message; NULL-terminated. */
-  char msg[UPB_STATUS_MAX_MESSAGE];
-};
-
-#define UPB_STATUS_INIT {true, 0, NULL, {0}}
-
-
-/** Built-in error spaces. ****************************************************/
-
-/* Errors raised by upb that we want to be able to detect programmatically. */
-typedef enum {
-  UPB_NOMEM   /* Can't reuse ENOMEM because it is POSIX, not ISO C. */
-} upb_errcode_t;
-
-extern upb_errorspace upb_upberr;
-
-void upb_upberr_setoom(upb_status *s);
-
-/* Since errno is defined by standard C, we define an error space for it in
- * core upb.  Other error spaces should be defined in other, platform-specific
- * modules. */
-
-extern upb_errorspace upb_errnoerr;
-
-
-/** upb::Allocator ************************************************************/
-
-/* A upb::Allocator 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. */
-UPB_DECLARE_TYPE(upb::Allocator, 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);
-
-#ifdef __cplusplus
-
-class upb::Allocator UPB_FINAL {
- public:
-  Allocator() {}
-
- private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(Allocator)
-
- public:
-#else
-struct upb_alloc {
-#endif  /* __cplusplus */
-  upb_alloc_func *func;
-};
-
-UPB_INLINE void *upb_malloc(upb_alloc *alloc, size_t size) {
-  UPB_ASSERT(size > 0);
-  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(size > 0);
-  return alloc->func(alloc, ptr, oldsize, size);
-}
-
-UPB_INLINE void upb_free(upb_alloc *alloc, void *ptr) {
-  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::Allocator interface, but it would not be as efficient for the
- * single-threaded case. */
-UPB_DECLARE_TYPE(upb::Arena, upb_arena)
-
-typedef void upb_cleanup_func(void *ud);
-
-#define UPB_ARENA_BLOCK_OVERHEAD (sizeof(size_t)*4)
-
-UPB_BEGIN_EXTERN_C
-
-void upb_arena_init(upb_arena *a);
-void upb_arena_init2(upb_arena *a, void *mem, size_t n, upb_alloc *alloc);
-void upb_arena_uninit(upb_arena *a);
-upb_alloc *upb_arena_alloc(upb_arena *a);
-bool upb_arena_addcleanup(upb_arena *a, upb_cleanup_func *func, void *ud);
-size_t upb_arena_bytesallocated(const upb_arena *a);
-void upb_arena_setnextblocksize(upb_arena *a, size_t size);
-void upb_arena_setmaxblocksize(upb_arena *a, size_t size);
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-
-class upb::Arena {
- public:
-  /* A simple arena with no initial memory block and the default allocator. */
-  Arena() { upb_arena_init(this); }
-
-  /* Constructs an arena with the given initial block which allocates blocks
-   * with the given allocator.  The given allocator must outlive the Arena.
-   *
-   * If you pass NULL for the allocator it will default to the global allocator
-   * upb_alloc_global, and NULL/0 for the initial block will cause there to be
-   * no initial block. */
-  Arena(void *mem, size_t len, Allocator* a) {
-    upb_arena_init2(this, mem, len, a);
-  }
-
-  ~Arena() { upb_arena_uninit(this); }
-
-  /* Sets the size of the next block the Arena will request (unless the
-   * requested allocation is larger).  Each block will double in size until the
-   * max limit is reached. */
-  void SetNextBlockSize(size_t size) { upb_arena_setnextblocksize(this, size); }
-
-  /* Sets the maximum block size.  No blocks larger than this will be requested
-   * from the underlying allocator unless individual arena allocations are
-   * larger. */
-  void SetMaxBlockSize(size_t size) { upb_arena_setmaxblocksize(this, size); }
-
-  /* Allows this arena to be used as a generic allocator.
-   *
-   * The arena does not need free() calls so when using Arena as an allocator
-   * it is safe to skip them.  However they are no-ops so there is no harm in
-   * calling free() either. */
-  Allocator* allocator() { return upb_arena_alloc(this); }
-
-  /* Add a cleanup function to run when the arena is destroyed.
-   * Returns false on out-of-memory. */
-  bool AddCleanup(upb_cleanup_func* func, void* ud) {
-    return upb_arena_addcleanup(this, func, ud);
-  }
-
-  /* Total number of bytes that have been allocated.  It is undefined what
-   * Realloc() does to this counter. */
-  size_t BytesAllocated() const {
-    return upb_arena_bytesallocated(this);
-  }
-
- private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(Arena)
-
-#else
-struct upb_arena {
-#endif  /* __cplusplus */
-  /* We implement the allocator interface.
-   * This must be the first member of upb_arena! */
-  upb_alloc alloc;
-
-  /* Allocator to allocate arena blocks.  We are responsible for freeing these
-   * when we are destroyed. */
-  upb_alloc *block_alloc;
-
-  size_t bytes_allocated;
-  size_t next_block_size;
-  size_t max_block_size;
-
-  /* Linked list of blocks.  Points to an arena_block, defined in env.c */
-  void *block_head;
-
-  /* Cleanup entries.  Pointer to a cleanup_ent, defined in env.c */
-  void *cleanup_head;
-
-  /* For future expansion, since the size of this struct is exposed to users. */
-  void *future1;
-  void *future2;
-};
-
-
-/* upb::Environment ***********************************************************/
-
-/* A upb::Environment provides a means for injecting malloc and an
- * error-reporting callback into encoders/decoders.  This allows them to be
- * independent of nearly all assumptions about their actual environment.
- *
- * It is also a container for allocating the encoders/decoders themselves that
- * insulates clients from knowing their actual size.  This provides ABI
- * compatibility even if the size of the objects change.  And this allows the
- * structure definitions to be in the .c files instead of the .h files, making
- * the .h files smaller and more readable.
- *
- * We might want to consider renaming this to "Pipeline" if/when the concept of
- * a pipeline element becomes more formalized. */
-UPB_DECLARE_TYPE(upb::Environment, upb_env)
-
-/* A function that receives an error report from an encoder or decoder.  The
- * callback can return true to request that the error should be recovered, but
- * if the error is not recoverable this has no effect. */
-typedef bool upb_error_func(void *ud, const upb_status *status);
-
-UPB_BEGIN_EXTERN_C
-
-void upb_env_init(upb_env *e);
-void upb_env_init2(upb_env *e, void *mem, size_t n, upb_alloc *alloc);
-void upb_env_uninit(upb_env *e);
-
-void upb_env_initonly(upb_env *e);
-
-upb_arena *upb_env_arena(upb_env *e);
-bool upb_env_ok(const upb_env *e);
-void upb_env_seterrorfunc(upb_env *e, upb_error_func *func, void *ud);
-
-/* Convenience wrappers around the methods of the contained arena. */
-void upb_env_reporterrorsto(upb_env *e, upb_status *s);
-bool upb_env_reporterror(upb_env *e, const upb_status *s);
-void *upb_env_malloc(upb_env *e, size_t size);
-void *upb_env_realloc(upb_env *e, void *ptr, size_t oldsize, size_t size);
-void upb_env_free(upb_env *e, void *ptr);
-bool upb_env_addcleanup(upb_env *e, upb_cleanup_func *func, void *ud);
-size_t upb_env_bytesallocated(const upb_env *e);
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-
-class upb::Environment {
- public:
-  /* The given Arena must outlive this environment. */
-  Environment() { upb_env_initonly(this); }
-
-  Environment(void *mem, size_t len, Allocator *a) : arena_(mem, len, a) {
-    upb_env_initonly(this);
-  }
-
-  Arena* arena() { return upb_env_arena(this); }
-
-  /* Set a custom error reporting function. */
-  void SetErrorFunction(upb_error_func* func, void* ud) {
-    upb_env_seterrorfunc(this, func, ud);
-  }
-
-  /* Set the error reporting function to simply copy the status to the given
-   * status and abort. */
-  void ReportErrorsTo(Status* status) { upb_env_reporterrorsto(this, status); }
-
-  /* Returns true if all allocations and AddCleanup() calls have succeeded,
-   * and no errors were reported with ReportError() (except ones that recovered
-   * successfully). */
-  bool ok() const { return upb_env_ok(this); }
-
-  /* Reports an error to this environment's callback, returning true if
-   * the caller should try to recover. */
-  bool ReportError(const Status* status) {
-    return upb_env_reporterror(this, status);
-  }
-
- private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(Environment)
-
-#else
-struct upb_env {
-#endif  /* __cplusplus */
-  upb_arena arena_;
-  upb_error_func *error_func_;
-  void *error_ud_;
-  bool ok_;
-};
-
-
-/* upb::InlinedArena **********************************************************/
-/* upb::InlinedEnvironment ****************************************************/
-
-/* upb::InlinedArena and upb::InlinedEnvironment seed their arenas with a
- * predefined amount of memory.  No heap memory will be allocated until the
- * initial block is exceeded.
- *
- * These types only exist in C++ */
-
-#ifdef __cplusplus
-
-template <int N> class upb::InlinedArena : public upb::Arena {
- public:
-  InlinedArena() : Arena(initial_block_, N, NULL) {}
-  explicit InlinedArena(Allocator* a) : Arena(initial_block_, N, a) {}
-
- private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(InlinedArena)
-
-  char initial_block_[N + UPB_ARENA_BLOCK_OVERHEAD];
-};
-
-template <int N> class upb::InlinedEnvironment : public upb::Environment {
- public:
-  InlinedEnvironment() : Environment(initial_block_, N, NULL) {}
-  explicit InlinedEnvironment(Allocator *a)
-      : Environment(initial_block_, N, a) {}
-
- private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(InlinedEnvironment)
-
-  char initial_block_[N + UPB_ARENA_BLOCK_OVERHEAD];
-};
-
-#endif  /* __cplusplus */
-
-
+#ifdef __cplusplus
+}  /* extern "C" */
+
+namespace upb {
+
+/* C++ Wrappers */
+inline Status::Status() { Clear(); }
+inline bool Status::ok() const { return upb_ok(this); }
+inline const char* Status::error_message() const {
+  return upb_status_errmsg(this);
+}
+inline void Status::SetErrorMessage(const char* msg) {
+  upb_status_seterrmsg(this, msg);
+}
+inline void Status::SetFormattedErrorMessage(const char* fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  upb_status_vseterrf(this, fmt, args);
+  va_end(args);
+}
+inline void Status::SetErrorCode(ErrorSpace* space, int code) {
+  upb_status_seterrcode(this, space, code);
+}
+inline void Status::Clear() { upb_status_clear(this); }
+inline void Status::CopyFrom(const Status& other) {
+  upb_status_copy(this, &other);
+}
+
+}  /* namespace upb */
+
+#endif
 
 #endif  /* UPB_H_ */
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 
 /* upb_value ******************************************************************/
 
@@ skipping 21 matching lines @@
 #endif
 } upb_value;
 
 #ifdef NDEBUG
 #define SET_TYPE(dest, val)      UPB_UNUSED(val)
 #else
 #define SET_TYPE(dest, val) dest = val
 #endif
 
 /* Like strdup(), which isn't always available since it's not ANSI C. */
-char *upb_strdup(const char *s, upb_alloc *a);
+char *upb_strdup(const char *s);
 /* Variant that works with a length-delimited rather than NULL-delimited string,
  * as supported by strtable. */
-char *upb_strdup2(const char *s, size_t len, upb_alloc *a);
-
-UPB_INLINE char *upb_gstrdup(const char *s) {
-  return upb_strdup(s, &upb_alloc_global);
-}
+char *upb_strdup2(const char *s, size_t len);
 
 UPB_INLINE void _upb_value_setval(upb_value *v, uint64_t val,
                                   upb_ctype_t ctype) {
   v->val = val;
   SET_TYPE(v->ctype, ctype);
 }
 
 UPB_INLINE upb_value _upb_value_val(uint64_t val, upb_ctype_t ctype) {
   upb_value ret;
   _upb_value_setval(&ret, val, ctype);
@@ skipping 12 matching lines @@
   UPB_INLINE void upb_value_set ## name(upb_value *val, type_t cval) { \
     val->val = (converter)cval; \
     SET_TYPE(val->ctype, proto_type); \
   } \
   UPB_INLINE upb_value upb_value_ ## name(type_t val) { \
     upb_value ret; \
     upb_value_set ## name(&ret, val); \
     return ret; \
   } \
   UPB_INLINE type_t upb_value_get ## name(upb_value val) { \
-    UPB_ASSERT_DEBUGVAR(val.ctype == proto_type); \
+    assert(val.ctype == proto_type); \
     return (type_t)(converter)val.val; \
   }
 
 FUNCS(int32,    int32,        int32_t,      int32_t,    UPB_CTYPE_INT32)
 FUNCS(int64,    int64,        int64_t,      int64_t,    UPB_CTYPE_INT64)
 FUNCS(uint32,   uint32,       uint32_t,     uint32_t,   UPB_CTYPE_UINT32)
 FUNCS(uint64,   uint64,       uint64_t,     uint64_t,   UPB_CTYPE_UINT64)
 FUNCS(bool,     _bool,        bool,         bool,       UPB_CTYPE_BOOL)
 FUNCS(cstr,     cstr,         char*,        uintptr_t,  UPB_CTYPE_CSTR)
 FUNCS(ptr,      ptr,          void*,        uintptr_t,  UPB_CTYPE_PTR)
@@ skipping 123 matching lines @@
   upb_ctype_t ctype;     /* Type of all values. */
   uint8_t size_lg2;      /* Size of the hashtable part is 2^size_lg2 entries. */
 
   /* Hash table entries.
    * Making this const isn't entirely accurate; what we really want is for it to
    * have the same const-ness as the table it's inside.  But there's no way to
    * declare that in C.  So we have to make it const so that we can statically
    * initialize const hash tables.  Then we cast away const when we have to.
    */
   const upb_tabent *entries;
-
-#ifndef NDEBUG
-  /* This table's allocator.  We make the user pass it in to every relevant
-   * function and only use this to check it in debug mode.  We do this solely
-   * to keep upb_table as small as possible.  This might seem slightly paranoid
-   * but the plan is to use upb_table for all map fields and extension sets in
-   * a forthcoming message representation, so there could be a lot of these.
-   * If this turns out to be too annoying later, we can change it (since this
-   * is an internal-only header file). */
-  upb_alloc *alloc;
-#endif
 } upb_table;
 
-#ifdef NDEBUG
-#  define UPB_TABLE_INIT(count, mask, ctype, size_lg2, entries) \
-     {count, mask, ctype, size_lg2, entries}
-#else
-#  ifdef UPB_DEBUG_REFS
-/* At the moment the only mutable tables we statically initialize are debug
- * ref tables. */
-#    define UPB_TABLE_INIT(count, mask, ctype, size_lg2, entries) \
-       {count, mask, ctype, size_lg2, entries, &upb_alloc_debugrefs}
-#  else
-#    define UPB_TABLE_INIT(count, mask, ctype, size_lg2, entries) \
-       {count, mask, ctype, size_lg2, entries, NULL}
-#  endif
-#endif
-
 typedef struct {
   upb_table t;
 } upb_strtable;
 
 #define UPB_STRTABLE_INIT(count, mask, ctype, size_lg2, entries) \
-  {UPB_TABLE_INIT(count, mask, ctype, size_lg2, entries)}
+  {{count, mask, ctype, size_lg2, entries}}
 
 #define UPB_EMPTY_STRTABLE_INIT(ctype)                           \
   UPB_STRTABLE_INIT(0, 0, ctype, 0, NULL)
 
 typedef struct {
   upb_table t;              /* For entries that don't fit in the array part. */
   const upb_tabval *array;  /* Array part of the table. See const note above. */
   size_t array_size;        /* Array part size. */
   size_t array_count;       /* Array part number of elements. */
 } upb_inttable;
 
 #define UPB_INTTABLE_INIT(count, mask, ctype, size_lg2, ent, a, asize, acount) \
-  {UPB_TABLE_INIT(count, mask, ctype, size_lg2, ent), a, asize, acount}
+  {{count, mask, ctype, size_lg2, ent}, a, asize, acount}
 
 #define UPB_EMPTY_INTTABLE_INIT(ctype) \
   UPB_INTTABLE_INIT(0, 0, ctype, 0, NULL, NULL, 0, 0)
 
 #define UPB_ARRAY_EMPTYENT -1
 
 UPB_INLINE size_t upb_table_size(const upb_table *t) {
   if (t->size_lg2 == 0)
     return 0;
   else
@@ skipping 19 matching lines @@
 static const upb_tabent *upb_getentry(const upb_table *t, uint32_t hash) {
   return t->entries + (hash & t->mask);
 }
 
 UPB_INLINE bool upb_arrhas(upb_tabval key) {
   return key.val != (uint64_t)-1;
 }
 
 /* Initialize and uninitialize a table, respectively.  If memory allocation
  * failed, false is returned that the table is uninitialized. */
-bool upb_inttable_init2(upb_inttable *table, upb_ctype_t ctype, upb_alloc *a);
-bool upb_strtable_init2(upb_strtable *table, upb_ctype_t ctype, upb_alloc *a);
-void upb_inttable_uninit2(upb_inttable *table, upb_alloc *a);
-void upb_strtable_uninit2(upb_strtable *table, upb_alloc *a);
-
-UPB_INLINE bool upb_inttable_init(upb_inttable *table, upb_ctype_t ctype) {
-  return upb_inttable_init2(table, ctype, &upb_alloc_global);
-}
-
-UPB_INLINE bool upb_strtable_init(upb_strtable *table, upb_ctype_t ctype) {
-  return upb_strtable_init2(table, ctype, &upb_alloc_global);
-}
-
-UPB_INLINE void upb_inttable_uninit(upb_inttable *table) {
-  upb_inttable_uninit2(table, &upb_alloc_global);
-}
-
-UPB_INLINE void upb_strtable_uninit(upb_strtable *table) {
-  upb_strtable_uninit2(table, &upb_alloc_global);
-}
+bool upb_inttable_init(upb_inttable *table, upb_ctype_t ctype);
+bool upb_strtable_init(upb_strtable *table, upb_ctype_t ctype);
+void upb_inttable_uninit(upb_inttable *table);
+void upb_strtable_uninit(upb_strtable *table);
 
 /* Returns the number of values in the table. */
 size_t upb_inttable_count(const upb_inttable *t);
 UPB_INLINE size_t upb_strtable_count(const upb_strtable *t) {
   return t->t.count;
 }
 
 /* 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.
  * Inttables must not insert a value of UINTPTR_MAX.
  *
  * If a table resize was required but memory allocation failed, false is
  * returned and the table is unchanged. */
-bool upb_inttable_insert2(upb_inttable *t, uintptr_t key, upb_value val,
-                          upb_alloc *a);
-bool upb_strtable_insert3(upb_strtable *t, const char *key, size_t len,
-                          upb_value val, upb_alloc *a);
-
-UPB_INLINE bool upb_inttable_insert(upb_inttable *t, uintptr_t key,
-                                    upb_value val) {
-  return upb_inttable_insert2(t, key, val, &upb_alloc_global);
-}
-
-UPB_INLINE bool upb_strtable_insert2(upb_strtable *t, const char *key,
-                                     size_t len, upb_value val) {
-  return upb_strtable_insert3(t, key, len, val, &upb_alloc_global);
-}
+bool upb_inttable_insert(upb_inttable *t, uintptr_t key, upb_value val);
+bool upb_strtable_insert2(upb_strtable *t, const char *key, size_t len,
+                          upb_value val);
 
 /* For NULL-terminated strings. */
 UPB_INLINE bool upb_strtable_insert(upb_strtable *t, const char *key,
                                     upb_value val) {
   return upb_strtable_insert2(t, key, strlen(key), val);
 }
 
 /* Looks up key in this table, returning "true" if the key was found.
  * If v is non-NULL, copies the value for this key into *v. */
 bool upb_inttable_lookup(const upb_inttable *t, uintptr_t key, upb_value *v);
 bool upb_strtable_lookup2(const upb_strtable *t, const char *key, size_t len,
                           upb_value *v);
 
 /* For NULL-terminated strings. */
 UPB_INLINE bool upb_strtable_lookup(const upb_strtable *t, const char *key,
                                     upb_value *v) {
   return upb_strtable_lookup2(t, key, strlen(key), v);
 }
 
 /* Removes an item from the table.  Returns true if the remove was successful,
  * and stores the removed item in *val if non-NULL. */
 bool upb_inttable_remove(upb_inttable *t, uintptr_t key, upb_value *val);
-bool upb_strtable_remove3(upb_strtable *t, const char *key, size_t len,
-                          upb_value *val, upb_alloc *alloc);
-
-UPB_INLINE bool upb_strtable_remove2(upb_strtable *t, const char *key,
-                                     size_t len, upb_value *val) {
-  return upb_strtable_remove3(t, key, len, val, &upb_alloc_global);
-}
+bool upb_strtable_remove2(upb_strtable *t, const char *key, size_t len,
+                          upb_value *val);
 
 /* For NULL-terminated strings. */
 UPB_INLINE bool upb_strtable_remove(upb_strtable *t, const char *key,
                                     upb_value *v) {
   return upb_strtable_remove2(t, key, strlen(key), v);
 }
 
 /* Updates an existing entry in an inttable.  If the entry does not exist,
  * returns false and does nothing.  Unlike insert/remove, this does not
  * invalidate iterators. */
 bool upb_inttable_replace(upb_inttable *t, uintptr_t key, upb_value val);
 
 /* Handy routines for treating an inttable like a stack.  May not be mixed with
  * other insert/remove calls. */
-bool upb_inttable_push2(upb_inttable *t, upb_value val, upb_alloc *a);
+bool upb_inttable_push(upb_inttable *t, upb_value val);
 upb_value upb_inttable_pop(upb_inttable *t);
 
-UPB_INLINE bool upb_inttable_push(upb_inttable *t, upb_value val) {
-  return upb_inttable_push2(t, val, &upb_alloc_global);
-}
-
 /* Convenience routines for inttables with pointer keys. */
-bool upb_inttable_insertptr2(upb_inttable *t, const void *key, upb_value val,
-                             upb_alloc *a);
+bool upb_inttable_insertptr(upb_inttable *t, const void *key, upb_value val);
 bool upb_inttable_removeptr(upb_inttable *t, const void *key, upb_value *val);
 bool upb_inttable_lookupptr(
     const upb_inttable *t, const void *key, upb_value *val);
 
-UPB_INLINE bool upb_inttable_insertptr(upb_inttable *t, const void *key,
-                                       upb_value val) {
-  return upb_inttable_insertptr2(t, key, val, &upb_alloc_global);
-}
-
 /* Optimizes the table for the current set of entries, for both memory use and
  * lookup time.  Client should call this after all entries have been inserted;
  * inserting more entries is legal, but will likely require a table resize. */
-void upb_inttable_compact2(upb_inttable *t, upb_alloc *a);
-
-UPB_INLINE void upb_inttable_compact(upb_inttable *t) {
-  upb_inttable_compact2(t, &upb_alloc_global);
-}
+void upb_inttable_compact(upb_inttable *t);
 
 /* A special-case inlinable version of the lookup routine for 32-bit
  * integers. */
 UPB_INLINE bool upb_inttable_lookup32(const upb_inttable *t, uint32_t key,
                                       upb_value *v) {
   *v = upb_value_int32(0);  /* Silence compiler warnings. */
   if (key < t->array_size) {
     upb_tabval arrval = t->array[key];
     if (upb_arrhas(arrval)) {
       _upb_value_setval(v, arrval.val, t->t.ctype);
       return true;
     } else {
       return false;
     }
   } else {
     const upb_tabent *e;
     if (t->t.entries == NULL) return false;
     for (e = upb_getentry(&t->t, upb_inthash(key)); true; e = e->next) {
       if ((uint32_t)e->key == key) {
         _upb_value_setval(v, e->val.val, t->t.ctype);
         return true;
       }
       if (e->next == NULL) return false;
     }
   }
 }
 
 /* Exposed for testing only. */
-bool upb_strtable_resize(upb_strtable *t, size_t size_lg2, upb_alloc *a);
+bool upb_strtable_resize(upb_strtable *t, size_t size_lg2);
 
 /* Iterators ******************************************************************/
 
 /* Iterators for int and string tables.  We are subject to some kind of unusual
  * design constraints:
  *
  * For high-level languages:
  *  - we must be able to guarantee that we don't crash or corrupt memory even if
  *    the program accesses an invalidated iterator.
  *
@@ skipping 24 matching lines @@
  */
 
 typedef struct {
   const upb_strtable *t;
   size_t index;
 } upb_strtable_iter;
 
 void upb_strtable_begin(upb_strtable_iter *i, const upb_strtable *t);
 void upb_strtable_next(upb_strtable_iter *i);
 bool upb_strtable_done(const upb_strtable_iter *i);
-const char *upb_strtable_iter_key(const upb_strtable_iter *i);
-size_t upb_strtable_iter_keylength(const upb_strtable_iter *i);
+const char *upb_strtable_iter_key(upb_strtable_iter *i);
+size_t upb_strtable_iter_keylength(upb_strtable_iter *i);
 upb_value upb_strtable_iter_value(const upb_strtable_iter *i);
 void upb_strtable_iter_setdone(upb_strtable_iter *i);
 bool upb_strtable_iter_isequal(const upb_strtable_iter *i1,
                                const upb_strtable_iter *i2);
 
 
 /* upb_inttable_iter **********************************************************/
 
 /*   upb_inttable_iter i;
  *   upb_inttable_begin(&i, t);
@@ skipping 32 matching lines @@
  * the code that originally created the object.
  *
  * Enabling this requires the application to define upb_lock()/upb_unlock()
  * functions that acquire/release a global mutex (or #define UPB_THREAD_UNSAFE).
  * For this reason we don't enable it by default, even in debug builds.
  */
 
 /* #define UPB_DEBUG_REFS */
 
 #ifdef __cplusplus
-namespace upb {
-class RefCounted;
-template <class T> class reffed_ptr;
-}
+namespace upb { class RefCounted; }
 #endif
 
 UPB_DECLARE_TYPE(upb::RefCounted, upb_refcounted)
 
 struct upb_refcounted_vtbl;
 
 #ifdef __cplusplus
 
 class upb::RefCounted {
  public:
@@ skipping 47 matching lines @@
 
   bool is_frozen;
 
 #ifdef UPB_DEBUG_REFS
   upb_inttable *refs;  /* Maps owner -> trackedref for incoming refs. */
   upb_inttable *ref2s; /* Set of targets for outgoing ref2s. */
 #endif
 };
 
 #ifdef UPB_DEBUG_REFS
-extern upb_alloc upb_alloc_debugrefs;
-#define UPB_REFCOUNT_INIT(vtbl, refs, ref2s) \
-    {&static_refcount, NULL, vtbl, 0, true, refs, ref2s}
+#define UPB_REFCOUNT_INIT(refs, ref2s) \
+    {&static_refcount, NULL, NULL, 0, true, refs, ref2s}
 #else
-#define UPB_REFCOUNT_INIT(vtbl, refs, ref2s) \
-    {&static_refcount, NULL, vtbl, 0, true}
+#define UPB_REFCOUNT_INIT(refs, ref2s) {&static_refcount, NULL, NULL, 0, true}
 #endif
 
 UPB_BEGIN_EXTERN_C
 
 /* It is better to use tracked refs when possible, for the extra debugging
  * capability.  But if this is not possible (because you don't have easy access
  * to a stable pointer value that is associated with the ref), you can pass
  * UPB_UNTRACKED_REF instead.  */
 extern const void *UPB_UNTRACKED_REF;
 
@@ skipping 112 matching lines @@
 }
 inline void RefCounted::DonateRef(const void *from, const void *to) const {
   upb_refcounted_donateref(this, from, to);
 }
 inline void RefCounted::CheckRef(const void *owner) const {
   upb_refcounted_checkref(this, owner);
 }
 }  /* namespace upb */
 #endif
 
-
-/* upb::reffed_ptr ************************************************************/
-
-#ifdef __cplusplus
-
-#include <algorithm>  /* For std::swap(). */
-
-/* Provides RAII semantics for upb refcounted objects.  Each reffed_ptr owns a
- * ref on whatever object it points to (if any). */
-template <class T> class upb::reffed_ptr {
- public:
-  reffed_ptr() : ptr_(NULL) {}
-
-  /* If ref_donor is NULL, takes a new ref, otherwise adopts from ref_donor. */
-  template <class U>
-  reffed_ptr(U* val, const void* ref_donor = NULL)
-      : ptr_(upb::upcast(val)) {
-    if (ref_donor) {
-      UPB_ASSERT(ptr_);
-      ptr_->DonateRef(ref_donor, this);
-    } else if (ptr_) {
-      ptr_->Ref(this);
-    }
-  }
-
-  template <class U>
-  reffed_ptr(const reffed_ptr<U>& other)
-      : ptr_(upb::upcast(other.get())) {
-    if (ptr_) ptr_->Ref(this);
-  }
-
-  reffed_ptr(const reffed_ptr& other)
-      : ptr_(upb::upcast(other.get())) {
-    if (ptr_) ptr_->Ref(this);
-  }
-
-  ~reffed_ptr() { if (ptr_) ptr_->Unref(this); }
-
-  template <class U>
-  reffed_ptr& operator=(const reffed_ptr<U>& other) {
-    reset(other.get());
-    return *this;
-  }
-
-  reffed_ptr& operator=(const reffed_ptr& other) {
-    reset(other.get());
-    return *this;
-  }
-
-  /* TODO(haberman): add C++11 move construction/assignment for greater
-   * efficiency. */
-
-  void swap(reffed_ptr& other) {
-    if (ptr_ == other.ptr_) {
-      return;
-    }
-
-    if (ptr_) ptr_->DonateRef(this, &other);
-    if (other.ptr_) other.ptr_->DonateRef(&other, this);
-    std::swap(ptr_, other.ptr_);
-  }
-
-  T& operator*() const {
-    UPB_ASSERT(ptr_);
-    return *ptr_;
-  }
-
-  T* operator->() const {
-    UPB_ASSERT(ptr_);
-    return ptr_;
-  }
-
-  T* get() const { return ptr_; }
-
-  /* If ref_donor is NULL, takes a new ref, otherwise adopts from ref_donor. */
-  template <class U>
-  void reset(U* ptr = NULL, const void* ref_donor = NULL) {
-    reffed_ptr(ptr, ref_donor).swap(*this);
-  }
-
-  template <class U>
-  reffed_ptr<U> down_cast() {
-    return reffed_ptr<U>(upb::down_cast<U*>(get()));
-  }
-
-  template <class U>
-  reffed_ptr<U> dyn_cast() {
-    return reffed_ptr<U>(upb::dyn_cast<U*>(get()));
-  }
-
-  /* Plain release() is unsafe; if we were the only owner, it would leak the
-   * object.  Instead we provide this: */
-  T* ReleaseTo(const void* new_owner) {
-    T* ret = NULL;
-    ptr_->DonateRef(this, new_owner);
-    std::swap(ret, ptr_);
-    return ret;
-  }
-
- private:
-  T* ptr_;
-};
-
-#endif  /* __cplusplus */
-
 #endif  /* UPB_REFCOUNT_H_ */
 
 #ifdef __cplusplus
 #include <cstring>
 #include <string>
 #include <vector>
 
 namespace upb {
 class Def;
 class EnumDef;
 class FieldDef;
-class FileDef;
 class MessageDef;
 class OneofDef;
 }
 #endif
 
 UPB_DECLARE_DERIVED_TYPE(upb::Def, upb::RefCounted, upb_def, upb_refcounted)
-UPB_DECLARE_DERIVED_TYPE(upb::OneofDef, upb::RefCounted, upb_oneofdef,
-                         upb_refcounted)
-UPB_DECLARE_DERIVED_TYPE(upb::FileDef, upb::RefCounted, upb_filedef,
-                         upb_refcounted)
 
 /* The maximum message depth that the type graph can have.  This is a resource
  * limit for the C stack since we sometimes need to recursively traverse the
  * graph.  Cycles are ok; the traversal will stop when it detects a cycle, but
  * we must hit the cycle before the maximum depth is reached.
  *
  * If having a single static limit is too inflexible, we can add another variant
  * of Def::Freeze that allows specifying this as a parameter. */
 #define UPB_MAX_MESSAGE_DEPTH 64
 
 
-/* upb::Def: base class for top-level defs  ***********************************/
+/* upb::Def: base class for defs  *********************************************/
 
-/* All the different kind of defs that can be defined at the top-level and put
- * in a SymbolTable or appear in a FileDef::defs() list.  This excludes some
- * defs (like oneofs and files).  It only includes fields because they can be
- * defined as extensions. */
+/* All the different kind of defs we support.  These correspond 1:1 with
+ * declarations in a .proto file. */
 typedef enum {
   UPB_DEF_MSG,
   UPB_DEF_FIELD,
   UPB_DEF_ENUM,
+  UPB_DEF_ONEOF,
   UPB_DEF_SERVICE,   /* Not yet implemented. */
   UPB_DEF_ANY = -1   /* Wildcard for upb_symtab_get*() */
 } upb_deftype_t;
 
 #ifdef __cplusplus
 
 /* The base class of all defs.  Its base is upb::RefCounted (use upb::upcast()
  * to convert). */
 class upb::Def {
  public:
   typedef upb_deftype_t Type;
 
   Def* Dup(const void *owner) const;
 
   /* upb::RefCounted methods like Ref()/Unref(). */
   UPB_REFCOUNTED_CPPMETHODS
 
   Type def_type() const;
 
   /* "fullname" is the def's fully-qualified name (eg. foo.bar.Message). */
   const char *full_name() const;
 
-  /* The final part of a def's name (eg. Message). */
-  const char *name() const;
-
   /* The def must be mutable.  Caller retains ownership of fullname.  Defs are
    * not required to have a name; if a def has no name when it is frozen, it
    * will remain an anonymous def.  On failure, returns false and details in "s"
    * if non-NULL. */
   bool set_full_name(const char* fullname, upb::Status* s);
   bool set_full_name(const std::string &fullname, upb::Status* s);
 
-  /* The file in which this def appears.  It is not necessary to add a def to a
-   * file (and consequently the accessor may return NULL).  Set this by calling
-   * file->Add(def). */
-  FileDef* file() const;
-
   /* Freezes the given defs; this validates all constraints and marks the defs
    * as frozen (read-only).  "defs" may not contain any fielddefs, but fields
    * of any msgdefs will be frozen.
    *
    * Symbolic references to sub-types and enum defaults must have already been
    * resolved.  Any mutable defs reachable from any of "defs" must also be in
    * the list; more formally, "defs" must be a transitive closure of mutable
    * defs.
    *
    * After this operation succeeds, the finalized defs must only be accessed
    * through a const pointer! */
-  static bool Freeze(Def* const* defs, size_t n, Status* status);
+  static bool Freeze(Def* const* defs, int n, Status* status);
   static bool Freeze(const std::vector<Def*>& defs, Status* status);
 
  private:
   UPB_DISALLOW_POD_OPS(Def, upb::Def)
 };
 
 #endif  /* __cplusplus */
 
 UPB_BEGIN_EXTERN_C
 
 /* Native C API. */
 upb_def *upb_def_dup(const upb_def *def, const void *owner);
 
 /* Include upb_refcounted methods like upb_def_ref()/upb_def_unref(). */
 UPB_REFCOUNTED_CMETHODS(upb_def, upb_def_upcast)
 
 upb_deftype_t upb_def_type(const upb_def *d);
 const char *upb_def_fullname(const upb_def *d);
-const char *upb_def_name(const upb_def *d);
-const upb_filedef *upb_def_file(const upb_def *d);
 bool upb_def_setfullname(upb_def *def, const char *fullname, upb_status *s);
-bool upb_def_freeze(upb_def *const *defs, size_t n, upb_status *s);
-
-/* Temporary API: for internal use only. */
-bool _upb_def_validate(upb_def *const*defs, size_t n, upb_status *s);
+bool upb_def_freeze(upb_def *const *defs, int n, upb_status *s);
 
 UPB_END_EXTERN_C
 
 
 /* upb::Def casts *************************************************************/
 
 #ifdef __cplusplus
 #define UPB_CPP_CASTS(cname, cpptype)                                          \
   namespace upb {                                                              \
   template <>                                                                  \
@@ skipping 28 matching lines @@
 
 /* Dynamic casts, for determining if a def is of a particular type at runtime.
  * Downcasts, for when some wants to assert that a def is of a particular type.
  * These are only checked if we are building debug. */
 #define UPB_DEF_CASTS(lower, upper, cpptype)                               \
   UPB_INLINE const upb_##lower *upb_dyncast_##lower(const upb_def *def) {  \
     if (upb_def_type(def) != UPB_DEF_##upper) return NULL;                 \
     return (upb_##lower *)def;                                             \
   }                                                                        \
   UPB_INLINE const upb_##lower *upb_downcast_##lower(const upb_def *def) { \
-    UPB_ASSERT(upb_def_type(def) == UPB_DEF_##upper);                          \
+    assert(upb_def_type(def) == UPB_DEF_##upper);                          \
     return (const upb_##lower *)def;                                       \
   }                                                                        \
   UPB_INLINE upb_##lower *upb_dyncast_##lower##_mutable(upb_def *def) {    \
     return (upb_##lower *)upb_dyncast_##lower(def);                        \
   }                                                                        \
   UPB_INLINE upb_##lower *upb_downcast_##lower##_mutable(upb_def *def) {   \
     return (upb_##lower *)upb_downcast_##lower(def);                       \
   }                                                                        \
   UPB_CPP_CASTS(lower, cpptype)
 
 #define UPB_DEFINE_DEF(cppname, lower, upper, cppmethods, members)             \
   UPB_DEFINE_CLASS2(cppname, upb::Def, upb::RefCounted, cppmethods,            \
                    members)                                                    \
   UPB_DEF_CASTS(lower, upper, cppname)
 
 #define UPB_DECLARE_DEF_TYPE(cppname, lower, upper) \
   UPB_DECLARE_DERIVED_TYPE2(cppname, upb::Def, upb::RefCounted, \
                             upb_ ## lower, upb_def, upb_refcounted) \
   UPB_DEF_CASTS(lower, upper, cppname)
 
 UPB_DECLARE_DEF_TYPE(upb::FieldDef, fielddef, FIELD)
 UPB_DECLARE_DEF_TYPE(upb::MessageDef, msgdef, MSG)
 UPB_DECLARE_DEF_TYPE(upb::EnumDef, enumdef, ENUM)
+UPB_DECLARE_DEF_TYPE(upb::OneofDef, oneofdef, ONEOF)
 
 #undef UPB_DECLARE_DEF_TYPE
 #undef UPB_DEF_CASTS
 #undef UPB_CPP_CASTS
 
 
 /* upb::FieldDef **************************************************************/
 
 /* The types a field can have.  Note that this list is not identical to the
  * types defined in descriptor.proto, which gives INT32 and SINT32 separate
@@ skipping 42 matching lines @@
   UPB_DESCRIPTOR_TYPE_MESSAGE  = 11,
   UPB_DESCRIPTOR_TYPE_BYTES    = 12,
   UPB_DESCRIPTOR_TYPE_UINT32   = 13,
   UPB_DESCRIPTOR_TYPE_ENUM     = 14,
   UPB_DESCRIPTOR_TYPE_SFIXED32 = 15,
   UPB_DESCRIPTOR_TYPE_SFIXED64 = 16,
   UPB_DESCRIPTOR_TYPE_SINT32   = 17,
   UPB_DESCRIPTOR_TYPE_SINT64   = 18
 } upb_descriptortype_t;
 
-typedef enum {
-  UPB_SYNTAX_PROTO2 = 2,
-  UPB_SYNTAX_PROTO3 = 3
-} upb_syntax_t;
-
 /* Maximum field number allowed for FieldDefs.  This is an inherent limit of the
  * protobuf wire format. */
 #define UPB_MAX_FIELDNUMBER ((1 << 29) - 1)
 
 #ifdef __cplusplus
 
 /* A upb_fielddef describes a single field in a message.  It is most often
  * found as a part of a upb_msgdef, but can also stand alone to represent
  * an extension.
  *
@@ skipping 34 matching lines @@
   /* Functionality from upb::Def. */
   const char* full_name() const;
 
   bool type_is_set() const;  /* set_[descriptor_]type() has been called? */
   Type type() const;         /* Requires that type_is_set() == true. */
   Label label() const;       /* Defaults to UPB_LABEL_OPTIONAL. */
   const char* name() const;  /* NULL if uninitialized. */
   uint32_t number() const;   /* Returns 0 if uninitialized. */
   bool is_extension() const;
 
-  /* Copies the JSON name for this field into the given buffer.  Returns the
-   * actual size of the JSON name, including the NULL terminator.  If the
-   * return value is 0, the JSON name is unset.  If the return value is
-   * greater than len, the JSON name was truncated.  The buffer is always
-   * NULL-terminated if len > 0.
-   *
-   * The JSON name always defaults to a camelCased version of the regular
-   * name.  However if the regular name is unset, the JSON name will be unset
-   * also.
-   */
-  size_t GetJsonName(char* buf, size_t len) const;
-
-  /* Convenience version of the above function which copies the JSON name
-   * into the given string, returning false if the name is not set. */
-  template <class T>
-  bool GetJsonName(T* str) {
-    str->resize(GetJsonName(NULL, 0));
-    GetJsonName(&(*str)[0], str->size());
-    return str->size() > 0;
-  }
-
   /* For UPB_TYPE_MESSAGE fields only where is_tag_delimited() == false,
    * indicates whether this field should have lazy parsing handlers that yield
    * the unparsed string for the submessage.
    *
    * TODO(haberman): I think we want to move this into a FieldOptions container
    * when we add support for custom options (the FieldOptions struct will
    * contain both regular FieldOptions like "lazy" *and* custom options). */
   bool lazy() const;
 
   /* For non-string, non-submessage fields, this indicates whether binary
    * protobufs are encoded in packed or non-packed format.
    *
    * TODO(haberman): see note above about putting options like this into a
    * FieldOptions container. */
   bool packed() const;
 
   /* An integer that can be used as an index into an array of fields for
    * whatever message this field belongs to.  Guaranteed to be less than
    * f->containing_type()->field_count().  May only be accessed once the def has
    * been finalized. */
-  uint32_t index() const;
+  int index() const;
 
   /* The MessageDef to which this field belongs.
    *
    * If this field has been added to a MessageDef, that message can be retrieved
    * directly (this is always the case for frozen FieldDefs).
    *
    * If the field has not yet been added to a MessageDef, you can set the name
    * of the containing type symbolically instead.  This is mostly useful for
    * extensions, where the extension is declared separately from the message. */
   const MessageDef* containing_type() const;
@@ skipping 11 matching lines @@
    * appropriately. */
   DescriptorType descriptor_type() const;
 
   /* Convenient field type tests. */
   bool IsSubMessage() const;
   bool IsString() const;
   bool IsSequence() const;
   bool IsPrimitive() const;
   bool IsMap() const;
 
-  /* Whether this field must be able to explicitly represent presence:
-   *
-   * * This is always false for repeated fields (an empty repeated field is
-   *   equivalent to a repeated field with zero entries).
-   *
-   * * This is always true for submessages.
-   *
-   * * For other fields, it depends on the message (see
-   *   MessageDef::SetPrimitivesHavePresence())
-   */
-  bool HasPresence() const;
-
   /* How integers are encoded.  Only meaningful for integer types.
    * Defaults to UPB_INTFMT_VARIABLE, and is reset when "type" changes. */
   IntegerFormat integer_format() const;
 
   /* Whether a submessage field is tag-delimited or not (if false, then
    * length-delimited).  May only be set when type() == UPB_TYPE_MESSAGE. */
   bool is_tag_delimited() const;
 
   /* Returns the non-string default value for this fielddef, which may either
    * be something the client set explicitly or the "default default" (0 for
@@ skipping 81 matching lines @@
    * MessageDef, and may not be set after that.
    *
    * "name" is the same as full_name()/set_full_name(), but since fielddefs
    * most often use simple, non-qualified names, we provide this accessor
    * also.  Generally only extensions will want to think of this name as
    * fully-qualified. */
   bool set_number(uint32_t number, upb::Status* s);
   bool set_name(const char* name, upb::Status* s);
   bool set_name(const std::string& name, upb::Status* s);
 
-  /* Sets the JSON name to the given string. */
-  /* TODO(haberman): implement.  Right now only default json_name (camelCase)
-   * is supported. */
-  bool set_json_name(const char* json_name, upb::Status* s);
-  bool set_json_name(const std::string& name, upb::Status* s);
-
-  /* Clears the JSON name. This will make it revert to its default, which is
-   * a camelCased version of the regular field name. */
-  void clear_json_name();
-
   void set_integer_format(IntegerFormat format);
   bool set_tag_delimited(bool tag_delimited, upb::Status* s);
 
   /* Sets default value for the field.  The call must exactly match the type
    * of the field.  Enum fields may use either setint32 or setstring to set
    * the default numerically or symbolically, respectively, but symbolic
    * defaults must be resolved before finalizing (see ResolveEnumDefault()).
    *
    * Changing the type of a field will reset its default. */
   void set_default_int64(int64_t val);
@@ skipping 44 matching lines @@
 
 bool upb_fielddef_typeisset(const upb_fielddef *f);
 upb_fieldtype_t upb_fielddef_type(const upb_fielddef *f);
 upb_descriptortype_t upb_fielddef_descriptortype(const upb_fielddef *f);
 upb_label_t 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);
 bool upb_fielddef_isextension(const upb_fielddef *f);
 bool upb_fielddef_lazy(const upb_fielddef *f);
 bool upb_fielddef_packed(const upb_fielddef *f);
-size_t upb_fielddef_getjsonname(const upb_fielddef *f, char *buf, size_t len);
 const upb_msgdef *upb_fielddef_containingtype(const upb_fielddef *f);
 const upb_oneofdef *upb_fielddef_containingoneof(const upb_fielddef *f);
 upb_msgdef *upb_fielddef_containingtype_mutable(upb_fielddef *f);
 const char *upb_fielddef_containingtypename(upb_fielddef *f);
 upb_intfmt_t upb_fielddef_intfmt(const upb_fielddef *f);
 uint32_t upb_fielddef_index(const upb_fielddef *f);
 bool upb_fielddef_istagdelim(const upb_fielddef *f);
 bool upb_fielddef_issubmsg(const upb_fielddef *f);
 bool upb_fielddef_isstring(const upb_fielddef *f);
 bool upb_fielddef_isseq(const upb_fielddef *f);
 bool upb_fielddef_isprimitive(const upb_fielddef *f);
 bool upb_fielddef_ismap(const upb_fielddef *f);
-bool upb_fielddef_haspresence(const upb_fielddef *f);
 int64_t upb_fielddef_defaultint64(const upb_fielddef *f);
 int32_t upb_fielddef_defaultint32(const upb_fielddef *f);
 uint64_t upb_fielddef_defaultuint64(const upb_fielddef *f);
 uint32_t upb_fielddef_defaultuint32(const upb_fielddef *f);
 bool upb_fielddef_defaultbool(const upb_fielddef *f);
 float upb_fielddef_defaultfloat(const upb_fielddef *f);
 double upb_fielddef_defaultdouble(const upb_fielddef *f);
 const char *upb_fielddef_defaultstr(const upb_fielddef *f, size_t *len);
 bool upb_fielddef_enumhasdefaultint32(const upb_fielddef *f);
 bool upb_fielddef_enumhasdefaultstr(const upb_fielddef *f);
 bool upb_fielddef_hassubdef(const upb_fielddef *f);
 const upb_def *upb_fielddef_subdef(const upb_fielddef *f);
 const upb_msgdef *upb_fielddef_msgsubdef(const upb_fielddef *f);
 const upb_enumdef *upb_fielddef_enumsubdef(const upb_fielddef *f);
 const char *upb_fielddef_subdefname(const upb_fielddef *f);
 
 void upb_fielddef_settype(upb_fielddef *f, upb_fieldtype_t type);
 void upb_fielddef_setdescriptortype(upb_fielddef *f, int type);
 void upb_fielddef_setlabel(upb_fielddef *f, upb_label_t label);
 bool upb_fielddef_setnumber(upb_fielddef *f, uint32_t number, upb_status *s);
 bool upb_fielddef_setname(upb_fielddef *f, const char *name, upb_status *s);
-bool upb_fielddef_setjsonname(upb_fielddef *f, const char *name, upb_status *s);
-bool upb_fielddef_clearjsonname(upb_fielddef *f);
 bool upb_fielddef_setcontainingtypename(upb_fielddef *f, const char *name,
                                         upb_status *s);
 void upb_fielddef_setisextension(upb_fielddef *f, bool is_extension);
 void upb_fielddef_setlazy(upb_fielddef *f, bool lazy);
 void upb_fielddef_setpacked(upb_fielddef *f, bool packed);
 void upb_fielddef_setintfmt(upb_fielddef *f, upb_intfmt_t fmt);
 void upb_fielddef_settagdelim(upb_fielddef *f, bool tag_delim);
 void upb_fielddef_setdefaultint64(upb_fielddef *f, int64_t val);
 void upb_fielddef_setdefaultint32(upb_fielddef *f, int32_t val);
 void upb_fielddef_setdefaultuint64(upb_fielddef *f, uint64_t val);
@@ skipping 20 matching lines @@
 bool upb_fielddef_checkintfmt(int32_t fmt);
 
 UPB_END_EXTERN_C
 
 
 /* upb::MessageDef ************************************************************/
 
 typedef upb_inttable_iter upb_msg_field_iter;
 typedef upb_strtable_iter upb_msg_oneof_iter;
 
-/* Well-known field tag numbers for map-entry messages. */
-#define UPB_MAPENTRY_KEY   1
-#define UPB_MAPENTRY_VALUE 2
-
 #ifdef __cplusplus
 
 /* Structure that describes a single .proto message type.
  *
  * Its base class is upb::Def (use upb::upcast() to convert). */
 class upb::MessageDef {
  public:
   /* Returns NULL if memory allocation failed. */
   static reffed_ptr<MessageDef> New();
 
   /* upb::RefCounted methods like Ref()/Unref(). */
   UPB_REFCOUNTED_CPPMETHODS
 
   /* Functionality from upb::Def. */
   const char* full_name() const;
-  const char* name() const;
   bool set_full_name(const char* fullname, Status* s);
   bool set_full_name(const std::string& fullname, Status* s);
 
   /* Call to freeze this MessageDef.
    * WARNING: this will fail if this message has any unfrozen submessages!
    * Messages with cycles must be frozen as a batch using upb::Def::Freeze(). */
   bool Freeze(Status* s);
 
   /* The number of fields that belong to the MessageDef. */
   int field_count() const;
@@ skipping 22 matching lines @@
   /* Adds a oneof (upb_oneofdef object) to a msgdef. Requires that the msgdef,
    * oneof, and any fielddefs are mutable, that the fielddefs contained in the
    * oneof do not have any name or number conflicts with existing fields in the
    * msgdef, and that the oneof's name is unique among all oneofs in the msgdef.
    * If the oneof is added successfully, all of its fields will be added
    * directly to the msgdef as well. In error cases, false is returned and the
    * msgdef is unchanged. */
   bool AddOneof(OneofDef* o, Status* s);
   bool AddOneof(const reffed_ptr<OneofDef>& o, Status* s);
 
-  upb_syntax_t syntax() const;
-
-  /* Returns false if we don't support this syntax value. */
-  bool set_syntax(upb_syntax_t syntax);
-
-  /* Set this to false to indicate that primitive fields should not have
-   * explicit presence information associated with them.  This will affect all
-   * fields added to this message.  Defaults to true. */
-  void SetPrimitivesHavePresence(bool have_presence);
-
   /* These return NULL if the field is not found. */
   FieldDef* FindFieldByNumber(uint32_t number);
   FieldDef* FindFieldByName(const char *name, size_t len);
   const FieldDef* FindFieldByNumber(uint32_t number) const;
   const FieldDef* FindFieldByName(const char* name, size_t len) const;
 
 
   FieldDef* FindFieldByName(const char *name) {
     return FindFieldByName(name, strlen(name));
   }
@@ skipping 165 matching lines @@
 UPB_BEGIN_EXTERN_C
 
 /* Returns NULL if memory allocation failed. */
 upb_msgdef *upb_msgdef_new(const void *owner);
 
 /* Include upb_refcounted methods like upb_msgdef_ref(). */
 UPB_REFCOUNTED_CMETHODS(upb_msgdef, upb_msgdef_upcast2)
 
 bool upb_msgdef_freeze(upb_msgdef *m, upb_status *status);
 
+const char *upb_msgdef_fullname(const upb_msgdef *m);
+bool upb_msgdef_setfullname(upb_msgdef *m, const char *fullname, upb_status *s);
+
 upb_msgdef *upb_msgdef_dup(const upb_msgdef *m, const void *owner);
-const char *upb_msgdef_fullname(const upb_msgdef *m);
-const char *upb_msgdef_name(const upb_msgdef *m);
-int upb_msgdef_numoneofs(const upb_msgdef *m);
-upb_syntax_t upb_msgdef_syntax(const upb_msgdef *m);
-
 bool upb_msgdef_addfield(upb_msgdef *m, upb_fielddef *f, const void *ref_donor,
                          upb_status *s);
 bool upb_msgdef_addoneof(upb_msgdef *m, upb_oneofdef *o, const void *ref_donor,
                          upb_status *s);
-bool upb_msgdef_setfullname(upb_msgdef *m, const char *fullname, upb_status *s);
-void upb_msgdef_setmapentry(upb_msgdef *m, bool map_entry);
-bool upb_msgdef_mapentry(const upb_msgdef *m);
-bool upb_msgdef_setsyntax(upb_msgdef *m, upb_syntax_t syntax);
 
 /* Field lookup in a couple of different variations:
  *   - itof = int to field
  *   - ntof = name to field
  *   - ntofz = name to field, null-terminated string. */
 const upb_fielddef *upb_msgdef_itof(const upb_msgdef *m, uint32_t i);
 const upb_fielddef *upb_msgdef_ntof(const upb_msgdef *m, const char *name,
                                     size_t len);
 int upb_msgdef_numfields(const upb_msgdef *m);
 
@@ skipping 21 matching lines @@
 UPB_INLINE const upb_oneofdef *upb_msgdef_ntooz(const upb_msgdef *m,
                                                const char *name) {
   return upb_msgdef_ntoo(m, name, strlen(name));
 }
 
 UPB_INLINE upb_oneofdef *upb_msgdef_ntoo_mutable(upb_msgdef *m,
                                                  const char *name, size_t len) {
   return (upb_oneofdef *)upb_msgdef_ntoo(m, name, len);
 }
 
-/* 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_msgdef_lookupname(const upb_msgdef *m, const char *name, size_t len,
-                           const upb_fielddef **f, const upb_oneofdef **o);
+void upb_msgdef_setmapentry(upb_msgdef *m, bool map_entry);
+bool upb_msgdef_mapentry(const upb_msgdef *m);
 
-UPB_INLINE bool upb_msgdef_lookupnamez(const upb_msgdef *m, const char *name,
-                                       const upb_fielddef **f,
-                                       const upb_oneofdef **o) {
-  return upb_msgdef_lookupname(m, name, strlen(name), f, o);
-}
+/* Well-known field tag numbers for map-entry messages. */
+#define UPB_MAPENTRY_KEY   1
+#define UPB_MAPENTRY_VALUE 2
 
-/* Iteration over fields and oneofs.  For example:
- *
- * upb_msg_field_iter i;
+const upb_oneofdef *upb_msgdef_findoneof(const upb_msgdef *m,
+                                          const char *name);
+int upb_msgdef_numoneofs(const upb_msgdef *m);
+
+/* upb_msg_field_iter i;
  * for(upb_msg_field_begin(&i, m);
  *     !upb_msg_field_done(&i);
  *     upb_msg_field_next(&i)) {
  *   upb_fielddef *f = upb_msg_iter_field(&i);
  *   // ...
  * }
  *
  * For C we don't have separate iterators for const and non-const.
  * It is the caller's responsibility to cast the upb_fielddef* to
  * const if the upb_msgdef* is const. */
@@ skipping 25 matching lines @@
 class upb::EnumDef {
  public:
   /* Returns NULL if memory allocation failed. */
   static reffed_ptr<EnumDef> New();
 
   /* upb::RefCounted methods like Ref()/Unref(). */
   UPB_REFCOUNTED_CPPMETHODS
 
   /* Functionality from upb::Def. */
   const char* full_name() const;
-  const char* name() const;
   bool set_full_name(const char* fullname, Status* s);
   bool set_full_name(const std::string& fullname, Status* s);
 
   /* Call to freeze this EnumDef. */
   bool Freeze(Status* s);
 
   /* The value that is used as the default when no field default is specified.
    * If not set explicitly, the first value that was added will be used.
    * The default value must be a member of the enum.
    * Requires that value_count() > 0. */
@@ skipping 54 matching lines @@
 upb_enumdef *upb_enumdef_new(const void *owner);
 upb_enumdef *upb_enumdef_dup(const upb_enumdef *e, const void *owner);
 
 /* Include upb_refcounted methods like upb_enumdef_ref(). */
 UPB_REFCOUNTED_CMETHODS(upb_enumdef, upb_enumdef_upcast2)
 
 bool upb_enumdef_freeze(upb_enumdef *e, upb_status *status);
 
 /* From upb_def. */
 const char *upb_enumdef_fullname(const upb_enumdef *e);
-const char *upb_enumdef_name(const upb_enumdef *e);
 bool upb_enumdef_setfullname(upb_enumdef *e, const char *fullname,
                              upb_status *s);
 
 int32_t upb_enumdef_default(const upb_enumdef *e);
 bool upb_enumdef_setdefault(upb_enumdef *e, int32_t val, upb_status *s);
 int upb_enumdef_numvals(const upb_enumdef *e);
 bool upb_enumdef_addval(upb_enumdef *e, const char *name, int32_t num,
                         upb_status *status);
 
 /* Enum lookups:
@@ skipping 21 matching lines @@
 int32_t upb_enum_iter_number(upb_enum_iter *iter);
 
 UPB_END_EXTERN_C
 
 /* upb::OneofDef **************************************************************/
 
 typedef upb_inttable_iter upb_oneof_iter;
 
 #ifdef __cplusplus
 
-/* Class that represents a oneof. */
+/* Class that represents a oneof.  Its base class is upb::Def (convert with
+ * upb::upcast()). */
 class upb::OneofDef {
  public:
   /* Returns NULL if memory allocation failed. */
   static reffed_ptr<OneofDef> New();
 
   /* upb::RefCounted methods like Ref()/Unref(). */
   UPB_REFCOUNTED_CPPMETHODS
 
+  /* Functionality from upb::Def. */
+  const char* full_name() const;
+
   /* Returns the MessageDef that owns this OneofDef. */
   const MessageDef* containing_type() const;
 
   /* Returns the name of this oneof. This is the name used to look up the oneof
    * by name once added to a message def. */
   const char* name() const;
   bool set_name(const char* name, Status* s);
-  bool set_name(const std::string& name, Status* s);
 
   /* Returns the number of fields currently defined in the oneof. */
   int field_count() const;
 
   /* Adds a field to the oneof. The field must not have been added to any other
    * oneof or msgdef. If the oneof is not yet part of a msgdef, then when the
    * oneof is eventually added to a msgdef, all fields added to the oneof will
    * also be added to the msgdef at that time. If the oneof is already part of a
    * msgdef, the field must either be a part of that msgdef already, or must not
    * be a part of any msgdef; in the latter case, the field is added to the
@@ skipping 73 matching lines @@
 
 #endif  /* __cplusplus */
 
 UPB_BEGIN_EXTERN_C
 
 /* Native C API. */
 upb_oneofdef *upb_oneofdef_new(const void *owner);
 upb_oneofdef *upb_oneofdef_dup(const upb_oneofdef *o, const void *owner);
 
 /* Include upb_refcounted methods like upb_oneofdef_ref(). */
-UPB_REFCOUNTED_CMETHODS(upb_oneofdef, upb_oneofdef_upcast)
+UPB_REFCOUNTED_CMETHODS(upb_oneofdef, upb_oneofdef_upcast2)
 
 const char *upb_oneofdef_name(const upb_oneofdef *o);
 bool upb_oneofdef_setname(upb_oneofdef *o, const char *name, upb_status *s);
 
 const upb_msgdef *upb_oneofdef_containingtype(const upb_oneofdef *o);
 int upb_oneofdef_numfields(const upb_oneofdef *o);
 bool upb_oneofdef_addfield(upb_oneofdef *o, upb_fielddef *f,
                            const void *ref_donor,
                            upb_status *s);
 
@@ skipping 15 matching lines @@
  *  }
  */
 void upb_oneof_begin(upb_oneof_iter *iter, const upb_oneofdef *o);
 void upb_oneof_next(upb_oneof_iter *iter);
 bool upb_oneof_done(upb_oneof_iter *iter);
 upb_fielddef *upb_oneof_iter_field(const upb_oneof_iter *iter);
 void upb_oneof_iter_setdone(upb_oneof_iter *iter);
 
 UPB_END_EXTERN_C
 
-
-/* upb::FileDef ***************************************************************/
-
-#ifdef __cplusplus
-
-/* Class that represents a .proto file with some things defined in it.
- *
- * Many users won't care about FileDefs, but they are necessary if you want to
- * read the values of file-level options. */
-class upb::FileDef {
- public:
-  /* Returns NULL if memory allocation failed. */
-  static reffed_ptr<FileDef> New();
-
-  /* upb::RefCounted methods like Ref()/Unref(). */
-  UPB_REFCOUNTED_CPPMETHODS
-
-  /* Get/set name of the file (eg. "foo/bar.proto"). */
-  const char* name() const;
-  bool set_name(const char* name, Status* s);
-  bool set_name(const std::string& name, Status* s);
-
-  /* Package name for definitions inside the file (eg. "foo.bar"). */
-  const char* package() const;
-  bool set_package(const char* package, Status* s);
-
-  /* Syntax for the file.  Defaults to proto2. */
-  upb_syntax_t syntax() const;
-  void set_syntax(upb_syntax_t syntax);
-
-  /* Get the list of defs from the file.  These are returned in the order that
-   * they were added to the FileDef. */
-  int def_count() const;
-  const Def* def(int index) const;
-  Def* def(int index);
-
-  /* Get the list of dependencies from the file.  These are returned in the
-   * order that they were added to the FileDef. */
-  int dependency_count() const;
-  const FileDef* dependency(int index) const;
-
-  /* Adds defs to this file.  The def must not already belong to another
-   * file.
-   *
-   * Note: this does *not* ensure that this def's name is unique in this file!
-   * Use a SymbolTable if you want to check this property.  Especially since
-   * properly checking uniqueness would require a check across *all* files
-   * (including dependencies). */
-  bool AddDef(Def* def, Status* s);
-  bool AddMessage(MessageDef* m, Status* s);
-  bool AddEnum(EnumDef* e, Status* s);
-  bool AddExtension(FieldDef* f, Status* s);
-
-  /* Adds a dependency of this file. */
-  bool AddDependency(const FileDef* file);
-
-  /* Freezes this FileDef and all messages/enums under it.  All subdefs must be
-   * resolved and all messages/enums must validate.  Returns true if this
-   * succeeded.
-   *
-   * TODO(haberman): should we care whether the file's dependencies are frozen
-   * already? */
-  bool Freeze(Status* s);
-
- private:
-  UPB_DISALLOW_POD_OPS(FileDef, upb::FileDef)
-};
-
-#endif
-
-UPB_BEGIN_EXTERN_C
-
-upb_filedef *upb_filedef_new(const void *owner);
-
-/* Include upb_refcounted methods like upb_msgdef_ref(). */
-UPB_REFCOUNTED_CMETHODS(upb_filedef, upb_filedef_upcast)
-
-const char *upb_filedef_name(const upb_filedef *f);
-const char *upb_filedef_package(const upb_filedef *f);
-upb_syntax_t upb_filedef_syntax(const upb_filedef *f);
-size_t upb_filedef_defcount(const upb_filedef *f);
-size_t upb_filedef_depcount(const upb_filedef *f);
-const upb_def *upb_filedef_def(const upb_filedef *f, size_t i);
-const upb_filedef *upb_filedef_dep(const upb_filedef *f, size_t i);
-
-bool upb_filedef_freeze(upb_filedef *f, upb_status *s);
-bool upb_filedef_setname(upb_filedef *f, const char *name, upb_status *s);
-bool upb_filedef_setpackage(upb_filedef *f, const char *package, upb_status *s);
-bool upb_filedef_setsyntax(upb_filedef *f, upb_syntax_t syntax, upb_status *s);
-
-bool upb_filedef_adddef(upb_filedef *f, upb_def *def, const void *ref_donor,
-                        upb_status *s);
-bool upb_filedef_adddep(upb_filedef *f, const upb_filedef *dep);
-
-UPB_INLINE bool upb_filedef_addmsg(upb_filedef *f, upb_msgdef *m,
-                                   const void *ref_donor, upb_status *s) {
-  return upb_filedef_adddef(f, upb_msgdef_upcast_mutable(m), ref_donor, s);
-}
-
-UPB_INLINE bool upb_filedef_addenum(upb_filedef *f, upb_enumdef *e,
-                                    const void *ref_donor, upb_status *s) {
-  return upb_filedef_adddef(f, upb_enumdef_upcast_mutable(e), ref_donor, s);
-}
-
-UPB_INLINE bool upb_filedef_addext(upb_filedef *file, upb_fielddef *f,
-                                   const void *ref_donor, upb_status *s) {
-  return upb_filedef_adddef(file, upb_fielddef_upcast_mutable(f), ref_donor, s);
-}
-UPB_INLINE upb_def *upb_filedef_mutabledef(upb_filedef *f, int i) {
-  return (upb_def*)upb_filedef_def(f, i);
-}
-
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
 
 UPB_INLINE const char* upb_safecstr(const std::string& str) {
-  UPB_ASSERT(str.size() == std::strlen(str.c_str()));
+  assert(str.size() == std::strlen(str.c_str()));
   return str.c_str();
 }
 
 /* Inline C++ wrappers. */
 namespace upb {
 
 inline Def* Def::Dup(const void* owner) const {
   return upb_def_dup(this, owner);
 }
 inline Def::Type Def::def_type() const { return upb_def_type(this); }
 inline const char* Def::full_name() const { return upb_def_fullname(this); }
-inline const char* Def::name() const { return upb_def_name(this); }
 inline bool Def::set_full_name(const char* fullname, Status* s) {
   return upb_def_setfullname(this, fullname, s);
 }
 inline bool Def::set_full_name(const std::string& fullname, Status* s) {
   return upb_def_setfullname(this, upb_safecstr(fullname), s);
 }
-inline bool Def::Freeze(Def* const* defs, size_t n, Status* status) {
+inline bool Def::Freeze(Def* const* defs, int n, Status* status) {
   return upb_def_freeze(defs, n, status);
 }
 inline bool Def::Freeze(const std::vector<Def*>& defs, Status* status) {
   return upb_def_freeze((Def* const*)&defs[0], defs.size(), status);
 }
 
 inline bool FieldDef::CheckType(int32_t val) {
   return upb_fielddef_checktype(val);
 }
 inline bool FieldDef::CheckLabel(int32_t val) {
   return upb_fielddef_checklabel(val);
 }
 inline bool FieldDef::CheckDescriptorType(int32_t val) {
   return upb_fielddef_checkdescriptortype(val);
 }
 inline bool FieldDef::CheckIntegerFormat(int32_t val) {
   return upb_fielddef_checkintfmt(val);
 }
 inline FieldDef::Type FieldDef::ConvertType(int32_t val) {
-  UPB_ASSERT(CheckType(val));
+  assert(CheckType(val));
   return static_cast<FieldDef::Type>(val);
 }
 inline FieldDef::Label FieldDef::ConvertLabel(int32_t val) {
-  UPB_ASSERT(CheckLabel(val));
+  assert(CheckLabel(val));
   return static_cast<FieldDef::Label>(val);
 }
 inline FieldDef::DescriptorType FieldDef::ConvertDescriptorType(int32_t val) {
-  UPB_ASSERT(CheckDescriptorType(val));
+  assert(CheckDescriptorType(val));
   return static_cast<FieldDef::DescriptorType>(val);
 }
 inline FieldDef::IntegerFormat FieldDef::ConvertIntegerFormat(int32_t val) {
-  UPB_ASSERT(CheckIntegerFormat(val));
+  assert(CheckIntegerFormat(val));
   return static_cast<FieldDef::IntegerFormat>(val);
 }
 
 inline reffed_ptr<FieldDef> FieldDef::New() {
   upb_fielddef *f = upb_fielddef_new(&f);
   return reffed_ptr<FieldDef>(f, &f);
 }
 inline FieldDef* FieldDef::Dup(const void* owner) const {
   return upb_fielddef_dup(this, owner);
 }
@@ skipping 14 matching lines @@
   return upb_fielddef_descriptortype(this);
 }
 inline FieldDef::Label FieldDef::label() const {
   return upb_fielddef_label(this);
 }
 inline uint32_t FieldDef::number() const { return upb_fielddef_number(this); }
 inline const char* FieldDef::name() const { return upb_fielddef_name(this); }
 inline bool FieldDef::is_extension() const {
   return upb_fielddef_isextension(this);
 }
-inline size_t FieldDef::GetJsonName(char* buf, size_t len) const {
-  return upb_fielddef_getjsonname(this, buf, len);
-}
 inline bool FieldDef::lazy() const {
   return upb_fielddef_lazy(this);
 }
 inline void FieldDef::set_lazy(bool lazy) {
   upb_fielddef_setlazy(this, lazy);
 }
 inline bool FieldDef::packed() const {
   return upb_fielddef_packed(this);
 }
-inline uint32_t FieldDef::index() const {
-  return upb_fielddef_index(this);
-}
 inline void FieldDef::set_packed(bool packed) {
   upb_fielddef_setpacked(this, packed);
 }
 inline const MessageDef* FieldDef::containing_type() const {
   return upb_fielddef_containingtype(this);
 }
 inline const OneofDef* FieldDef::containing_oneof() const {
   return upb_fielddef_containingoneof(this);
 }
 inline const char* FieldDef::containing_type_name() {
   return upb_fielddef_containingtypename(this);
 }
 inline bool FieldDef::set_number(uint32_t number, Status* s) {
   return upb_fielddef_setnumber(this, number, s);
 }
 inline bool FieldDef::set_name(const char *name, Status* s) {
   return upb_fielddef_setname(this, name, s);
 }
 inline bool FieldDef::set_name(const std::string& name, Status* s) {
   return upb_fielddef_setname(this, upb_safecstr(name), s);
 }
-inline bool FieldDef::set_json_name(const char *name, Status* s) {
-  return upb_fielddef_setjsonname(this, name, s);
-}
-inline bool FieldDef::set_json_name(const std::string& name, Status* s) {
-  return upb_fielddef_setjsonname(this, upb_safecstr(name), s);
-}
-inline void FieldDef::clear_json_name() {
-  upb_fielddef_clearjsonname(this);
-}
 inline bool FieldDef::set_containing_type_name(const char *name, Status* s) {
   return upb_fielddef_setcontainingtypename(this, name, s);
 }
 inline bool FieldDef::set_containing_type_name(const std::string &name,
                                                Status *s) {
   return upb_fielddef_setcontainingtypename(this, upb_safecstr(name), s);
 }
 inline void FieldDef::set_type(upb_fieldtype_t type) {
   upb_fielddef_settype(this, type);
 }
@@ skipping 94 matching lines @@
   return upb_fielddef_setsubdefname(this, upb_safecstr(name), s);
 }
 
 inline reffed_ptr<MessageDef> MessageDef::New() {
   upb_msgdef *m = upb_msgdef_new(&m);
   return reffed_ptr<MessageDef>(m, &m);
 }
 inline const char *MessageDef::full_name() const {
   return upb_msgdef_fullname(this);
 }
-inline const char *MessageDef::name() const {
-  return upb_msgdef_name(this);
-}
-inline upb_syntax_t MessageDef::syntax() const {
-  return upb_msgdef_syntax(this);
-}
 inline bool MessageDef::set_full_name(const char* fullname, Status* s) {
   return upb_msgdef_setfullname(this, fullname, s);
 }
 inline bool MessageDef::set_full_name(const std::string& fullname, Status* s) {
   return upb_msgdef_setfullname(this, upb_safecstr(fullname), s);
 }
-inline bool MessageDef::set_syntax(upb_syntax_t syntax) {
-  return upb_msgdef_setsyntax(this, syntax);
-}
 inline bool MessageDef::Freeze(Status* status) {
   return upb_msgdef_freeze(this, status);
 }
 inline int MessageDef::field_count() const {
   return upb_msgdef_numfields(this);
 }
 inline int MessageDef::oneof_count() const {
   return upb_msgdef_numoneofs(this);
 }
 inline bool MessageDef::AddField(upb_fielddef* f, Status* s) {
@@ skipping 161 matching lines @@
   return !(*this == other);
 }
 
 inline reffed_ptr<EnumDef> EnumDef::New() {
   upb_enumdef *e = upb_enumdef_new(&e);
   return reffed_ptr<EnumDef>(e, &e);
 }
 inline const char* EnumDef::full_name() const {
   return upb_enumdef_fullname(this);
 }
-inline const char* EnumDef::name() const {
-  return upb_enumdef_name(this);
-}
 inline bool EnumDef::set_full_name(const char* fullname, Status* s) {
   return upb_enumdef_setfullname(this, fullname, s);
 }
 inline bool EnumDef::set_full_name(const std::string& fullname, Status* s) {
   return upb_enumdef_setfullname(this, upb_safecstr(fullname), s);
 }
 inline bool EnumDef::Freeze(Status* status) {
   return upb_enumdef_freeze(this, status);
 }
 inline int32_t EnumDef::default_value() const {
@@ skipping 29 matching lines @@
 inline const char* EnumDef::Iterator::name() {
   return upb_enum_iter_name(&iter_);
 }
 inline bool EnumDef::Iterator::Done() { return upb_enum_done(&iter_); }
 inline void EnumDef::Iterator::Next() { return upb_enum_next(&iter_); }
 
 inline reffed_ptr<OneofDef> OneofDef::New() {
   upb_oneofdef *o = upb_oneofdef_new(&o);
   return reffed_ptr<OneofDef>(o, &o);
 }
+inline const char* OneofDef::full_name() const {
+  return upb_oneofdef_name(this);
+}
 
 inline const MessageDef* OneofDef::containing_type() const {
   return upb_oneofdef_containingtype(this);
 }
 inline const char* OneofDef::name() const {
   return upb_oneofdef_name(this);
 }
 inline bool OneofDef::set_name(const char* name, Status* s) {
   return upb_oneofdef_setname(this, name, s);
 }
-inline bool OneofDef::set_name(const std::string& name, Status* s) {
-  return upb_oneofdef_setname(this, upb_safecstr(name), s);
-}
 inline int OneofDef::field_count() const {
   return upb_oneofdef_numfields(this);
 }
 inline bool OneofDef::AddField(FieldDef* field, Status* s) {
   return upb_oneofdef_addfield(this, field, NULL, s);
 }
 inline bool OneofDef::AddField(const reffed_ptr<FieldDef>& field, Status* s) {
   return upb_oneofdef_addfield(this, field.get(), NULL, s);
 }
 inline const FieldDef* OneofDef::FindFieldByName(const char* name,
@@ skipping 48 matching lines @@
 }
 inline bool OneofDef::const_iterator::operator==(
     const const_iterator &other) const {
   return upb_inttable_iter_isequal(&iter_, &other.iter_);
 }
 inline bool OneofDef::const_iterator::operator!=(
     const const_iterator &other) const {
   return !(*this == other);
 }
 
-inline reffed_ptr<FileDef> FileDef::New() {
-  upb_filedef *f = upb_filedef_new(&f);
-  return reffed_ptr<FileDef>(f, &f);
-}
-
-inline const char* FileDef::name() const {
-  return upb_filedef_name(this);
-}
-inline bool FileDef::set_name(const char* name, Status* s) {
-  return upb_filedef_setname(this, name, s);
-}
-inline bool FileDef::set_name(const std::string& name, Status* s) {
-  return upb_filedef_setname(this, upb_safecstr(name), s);
-}
-inline const char* FileDef::package() const {
-  return upb_filedef_package(this);
-}
-inline bool FileDef::set_package(const char* package, Status* s) {
-  return upb_filedef_setpackage(this, package, s);
-}
-inline int FileDef::def_count() const {
-  return upb_filedef_defcount(this);
-}
-inline const Def* FileDef::def(int index) const {
-  return upb_filedef_def(this, index);
-}
-inline Def* FileDef::def(int index) {
-  return const_cast<Def*>(upb_filedef_def(this, index));
-}
-inline int FileDef::dependency_count() const {
-  return upb_filedef_depcount(this);
-}
-inline const FileDef* FileDef::dependency(int index) const {
-  return upb_filedef_dep(this, index);
-}
-inline bool FileDef::AddDef(Def* def, Status* s) {
-  return upb_filedef_adddef(this, def, NULL, s);
-}
-inline bool FileDef::AddMessage(MessageDef* m, Status* s) {
-  return upb_filedef_addmsg(this, m, NULL, s);
-}
-inline bool FileDef::AddEnum(EnumDef* e, Status* s) {
-  return upb_filedef_addenum(this, e, NULL, s);
-}
-inline bool FileDef::AddExtension(FieldDef* f, Status* s) {
-  return upb_filedef_addext(this, f, NULL, s);
-}
-inline bool FileDef::AddDependency(const FileDef* file) {
-  return upb_filedef_adddep(this, file);
-}
-
 }  /* namespace upb */
 #endif
 
 #endif /* UPB_DEF_H_ */
 /*
 ** This file contains definitions of structs that should be considered private
 ** and NOT stable across versions of upb.
 **
 ** The only reason they are declared here and not in .c files is to allow upb
 ** and the application (if desired) to embed statically-initialized instances
@@ skipping 18 matching lines @@
 
 /* upb_refcounted *************************************************************/
 
 
 /* upb_def ********************************************************************/
 
 struct upb_def {
   upb_refcounted base;
 
   const char *fullname;
-  const upb_filedef* file;
   char type;  /* A upb_deftype_t (char to save space) */
 
   /* Used as a flag during the def's mutable stage.  Must be false unless
    * it is currently being used by a function on the stack.  This allows
    * us to easily determine which defs were passed into the function's
    * current invocation. */
   bool came_from_user;
 };
 
-#define UPB_DEF_INIT(name, type, vtbl, refs, ref2s) \
-    { UPB_REFCOUNT_INIT(vtbl, refs, ref2s), name, NULL, type, false }
+#define UPB_DEF_INIT(name, type, refs, ref2s) \
+    { UPB_REFCOUNT_INIT(refs, ref2s), name, type, false }
 
 
 /* upb_fielddef ***************************************************************/
 
 struct upb_fielddef {
   upb_def base;
 
   union {
     int64_t sint;
     uint64_t uint;
@@ skipping 19 matching lines @@
   bool packed_;
   upb_intfmt_t intfmt;
   bool tagdelim;
   upb_fieldtype_t type_;
   upb_label_t label_;
   uint32_t number_;
   uint32_t selector_base;  /* Used to index into a upb::Handlers table. */
   uint32_t index_;
 };
 
-extern const struct upb_refcounted_vtbl upb_fielddef_vtbl;
-
 #define UPB_FIELDDEF_INIT(label, type, intfmt, tagdelim, is_extension, lazy,   \
                           packed, name, num, msgdef, subdef, selector_base,    \
                           index, defaultval, refs, ref2s)                      \
   {                                                                            \
-    UPB_DEF_INIT(name, UPB_DEF_FIELD, &upb_fielddef_vtbl, refs, ref2s),        \
-        defaultval, {msgdef}, {subdef}, NULL, false, false,                    \
+    UPB_DEF_INIT(name, UPB_DEF_FIELD, refs, ref2s), defaultval, {msgdef},      \
+        {subdef}, NULL, false, false,                                          \
         type == UPB_TYPE_STRING || type == UPB_TYPE_BYTES, true, is_extension, \
         lazy, packed, intfmt, tagdelim, type, label, num, selector_base, index \
   }
 
 
 /* upb_msgdef *****************************************************************/
 
 struct upb_msgdef {
   upb_def base;
 
   size_t selector_count;
   uint32_t submsg_field_count;
 
   /* Tables for looking up fields by number and name. */
   upb_inttable itof;  /* int to field */
-  upb_strtable ntof;  /* name to field/oneof */
+  upb_strtable ntof;  /* name to field */
 
-  /* Is this a map-entry message? */
+  /* Tables for looking up oneofs by name. */
+  upb_strtable ntoo;  /* name to oneof */
+
+  /* Is this a map-entry message?
+   * TODO: set this flag properly for static descriptors; regenerate
+   * descriptor.upb.c. */
   bool map_entry;
 
-  /* Whether this message has proto2 or proto3 semantics. */
-  upb_syntax_t syntax;
-
   /* TODO(haberman): proper extension ranges (there can be multiple). */
 };
 
-extern const struct upb_refcounted_vtbl upb_msgdef_vtbl;
-
 /* TODO: also support static initialization of the oneofs table. This will be
  * needed if we compile in descriptors that contain oneofs. */
 #define UPB_MSGDEF_INIT(name, selector_count, submsg_field_count, itof, ntof, \
-                        map_entry, syntax, refs, ref2s)                       \
+                        refs, ref2s)                                          \
   {                                                                           \
-    UPB_DEF_INIT(name, UPB_DEF_MSG, &upb_fielddef_vtbl, refs, ref2s),         \
-        selector_count, submsg_field_count, itof, ntof, map_entry, syntax     \
+    UPB_DEF_INIT(name, UPB_DEF_MSG, refs, ref2s), selector_count,             \
+        submsg_field_count, itof, ntof,                                       \
+        UPB_EMPTY_STRTABLE_INIT(UPB_CTYPE_PTR), false                         \
   }
 
 
 /* upb_enumdef ****************************************************************/
 
 struct upb_enumdef {
   upb_def base;
 
   upb_strtable ntoi;
   upb_inttable iton;
   int32_t defaultval;
 };
 
-extern const struct upb_refcounted_vtbl upb_enumdef_vtbl;
-
 #define UPB_ENUMDEF_INIT(name, ntoi, iton, defaultval, refs, ref2s) \
-  { UPB_DEF_INIT(name, UPB_DEF_ENUM, &upb_enumdef_vtbl, refs, ref2s), ntoi,    \
-    iton, defaultval }
+  { UPB_DEF_INIT(name, UPB_DEF_ENUM, refs, ref2s), ntoi, iton, defaultval }
 
 
 /* upb_oneofdef ***************************************************************/
 
 struct upb_oneofdef {
-  upb_refcounted base;
+  upb_def base;
 
-  const char *name;
   upb_strtable ntof;
   upb_inttable itof;
   const upb_msgdef *parent;
 };
 
-extern const struct upb_refcounted_vtbl upb_oneofdef_vtbl;
-
 #define UPB_ONEOFDEF_INIT(name, ntof, itof, refs, ref2s) \
-  { UPB_REFCOUNT_INIT(&upb_oneofdef_vtbl, refs, ref2s), name, ntof, itof }
+  { UPB_DEF_INIT(name, UPB_DEF_ENUM, refs, ref2s), ntof, itof }
 
 
 /* upb_symtab *****************************************************************/
 
 struct upb_symtab {
   upb_refcounted base;
 
   upb_strtable symtab;
 };
 
-struct upb_filedef {
-  upb_refcounted base;
+#define UPB_SYMTAB_INIT(symtab, refs, ref2s) \
+  { UPB_REFCOUNT_INIT(refs, ref2s), symtab }
 
-  const char *name;
-  const char *package;
-  upb_syntax_t syntax;
-
-  upb_inttable defs;
-  upb_inttable deps;
-};
-
-extern const struct upb_refcounted_vtbl upb_filedef_vtbl;
 
 #endif  /* UPB_STATICINIT_H_ */
 /*
 ** upb::Handlers (upb_handlers)
 **
 ** A upb_handlers is like a virtual table for a upb_msgdef.  Each field of the
 ** message can have associated functions that will be called when we are
 ** parsing or visiting a stream of data.  This is similar to how handlers work
 ** in SAX (the Simple API for XML).
 **
@@ skipping 593 matching lines @@
   typedef T FuncPtr;
 
   /* Intentionally implicit. */
   template <class F> Handler(F func);
   ~Handler();
 
  private:
   void AddCleanup(Handlers* h) const {
     if (cleanup_func_) {
       bool ok = h->AddCleanup(cleanup_data_, cleanup_func_);
-      UPB_ASSERT(ok);
+      UPB_ASSERT_VAR(ok, ok);
     }
   }
 
   UPB_DISALLOW_COPY_AND_ASSIGN(Handler)
   friend class Handlers;
   FuncPtr handler_;
   mutable HandlerAttributes attr_;
   mutable bool registered_;
   void *cleanup_data_;
   upb_handlerfree *cleanup_func_;
@@ skipping 999 matching lines @@
 /* utype/ltype are upper/lower-case, ctype is canonical C type, vtype is
  * variant C type. */
 #define TYPE_METHODS(utype, ltype, ctype, vtype)                               \
   template <> struct CanonicalType<vtype> {                                    \
     typedef ctype Type;                                                        \
   };                                                                           \
   template <>                                                                  \
   inline bool Handlers::SetValueHandler<vtype>(                                \
       const FieldDef *f,                                                       \
       const Handlers::utype ## Handler& handler) {                             \
-    UPB_ASSERT(!handler.registered_);                                              \
+    assert(!handler.registered_);                                              \
     handler.AddCleanup(this);                                                  \
     handler.registered_ = true;                                                \
     return upb_handlers_set##ltype(this, f, handler.handler_, &handler.attr_); \
   }                                                                            \
 
 TYPE_METHODS(Double, double, double,   double)
 TYPE_METHODS(Float,  float,  float,    float)
 TYPE_METHODS(UInt64, uint64, uint64_t, UPB_UINT64_T)
 TYPE_METHODS(UInt32, uint32, uint32_t, UPB_UINT32_T)
 TYPE_METHODS(Int64,  int64,  int64_t,  UPB_INT64_T)
@@ skipping 91 matching lines @@
    * This is all nonsense for non START* handlers, but it doesn't matter because
    * in that case the value will be ignored. */
   typedef typename FirstUnlessVoidOrBool<typename F::FuncInfo::Return,
                                          typename F::FuncInfo::Closure>::value
       EffectiveReturn;
   attr_.SetReturnClosureType(UniquePtrForType<EffectiveReturn>());
 }
 
 template <class T>
 inline Handler<T>::~Handler() {
-  UPB_ASSERT(registered_);
+  assert(registered_);
 }
 
 inline HandlerAttributes::HandlerAttributes() { upb_handlerattr_init(this); }
 inline HandlerAttributes::~HandlerAttributes() { upb_handlerattr_uninit(this); }
 inline bool HandlerAttributes::SetHandlerData(const void *hd) {
   return upb_handlerattr_sethandlerdata(this, hd);
 }
 inline const void* HandlerAttributes::handler_data() const {
   return upb_handlerattr_handlerdata(this);
 }
@@ skipping 65 matching lines @@
   return upb_handlers_freeze((Handlers* const*)&h[0], h.size(), status);
 }
 inline const MessageDef *Handlers::message_def() const {
   return upb_handlers_msgdef(this);
 }
 inline bool Handlers::AddCleanup(void *p, upb_handlerfree *func) {
   return upb_handlers_addcleanup(this, p, func);
 }
 inline bool Handlers::SetStartMessageHandler(
     const Handlers::StartMessageHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
+  assert(!handler.registered_);
   handler.registered_ = true;
   handler.AddCleanup(this);
   return upb_handlers_setstartmsg(this, handler.handler_, &handler.attr_);
 }
 inline bool Handlers::SetEndMessageHandler(
     const Handlers::EndMessageHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
+  assert(!handler.registered_);
   handler.registered_ = true;
   handler.AddCleanup(this);
   return upb_handlers_setendmsg(this, handler.handler_, &handler.attr_);
 }
 inline bool Handlers::SetStartStringHandler(const FieldDef *f,
                                             const StartStringHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
+  assert(!handler.registered_);
   handler.registered_ = true;
   handler.AddCleanup(this);
   return upb_handlers_setstartstr(this, f, handler.handler_, &handler.attr_);
 }
 inline bool Handlers::SetEndStringHandler(const FieldDef *f,
                                           const EndFieldHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
+  assert(!handler.registered_);
   handler.registered_ = true;
   handler.AddCleanup(this);
   return upb_handlers_setendstr(this, f, handler.handler_, &handler.attr_);
 }
 inline bool Handlers::SetStringHandler(const FieldDef *f,
                                        const StringHandler& handler) {
-  UPB_ASSERT(!handler.registered_);
+  assert(!handler.registered_);
   handler.registered_ = true;
   handler.AddCleanup(this);
   return upb_handlers_setstring(this, f, handler.handler_, &handler.attr_);
 }
 inline bool Handlers::SetStartSequenceHandler(
     const FieldDef *f, const StartFieldHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
+  assert(!handler.registered_);
   handler.registered_ = true;
   handler.AddCleanup(this);
   return upb_handlers_setstartseq(this, f, handler.handler_, &handler.attr_);
 }
 inline bool Handlers::SetStartSubMessageHandler(
     const FieldDef *f, const StartFieldHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
+  assert(!handler.registered_);
   handler.registered_ = true;
   handler.AddCleanup(this);
   return upb_handlers_setstartsubmsg(this, f, handler.handler_, &handler.attr_);
 }
 inline bool Handlers::SetEndSubMessageHandler(const FieldDef *f,
                                               const EndFieldHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
+  assert(!handler.registered_);
   handler.registered_ = true;
   handler.AddCleanup(this);
   return upb_handlers_setendsubmsg(this, f, handler.handler_, &handler.attr_);
 }
 inline bool Handlers::SetEndSequenceHandler(const FieldDef *f,
                                             const EndFieldHandler &handler) {
-  UPB_ASSERT(!handler.registered_);
+  assert(!handler.registered_);
   handler.registered_ = true;
   handler.AddCleanup(this);
   return upb_handlers_setendseq(this, f, handler.handler_, &handler.attr_);
 }
 inline bool Handlers::SetSubHandlers(const FieldDef *f, const Handlers *sub) {
   return upb_handlers_setsubhandlers(this, f, sub);
 }
 inline const Handlers *Handlers::GetSubHandlers(const FieldDef *f) const {
   return upb_handlers_getsubhandlers(this, f);
 }
@@ skipping 34 matching lines @@
 #undef UPB_UINT32ALT_T
 #undef UPB_INT64_T
 #undef UPB_UINT64_T
 #undef UPB_INT64ALT_T
 #undef UPB_UINT64ALT_T
 
 #endif  /* UPB_HANDLERS_INL_H_ */
 
 #endif  /* UPB_HANDLERS_H */
 /*
+** upb::Environment (upb_env)
+**
+** A upb::Environment provides a means for injecting malloc and an
+** error-reporting callback into encoders/decoders.  This allows them to be
+** independent of nearly all assumptions about their actual environment.
+**
+** It is also a container for allocating the encoders/decoders themselves that
+** insulates clients from knowing their actual size.  This provides ABI
+** compatibility even if the size of the objects change.  And this allows the
+** structure definitions to be in the .c files instead of the .h files, making
+** the .h files smaller and more readable.
+*/
+
+
+#ifndef UPB_ENV_H_
+#define UPB_ENV_H_
+
+#ifdef __cplusplus
+namespace upb {
+class Environment;
+class SeededAllocator;
+}
+#endif
+
+UPB_DECLARE_TYPE(upb::Environment, upb_env)
+UPB_DECLARE_TYPE(upb::SeededAllocator, upb_seededalloc)
+
+typedef void *upb_alloc_func(void *ud, void *ptr, size_t oldsize, size_t size);
+typedef void upb_cleanup_func(void *ud);
+typedef bool upb_error_func(void *ud, const upb_status *status);
+
+#ifdef __cplusplus
+
+/* An environment is *not* thread-safe. */
+class upb::Environment {
+ public:
+  Environment();
+  ~Environment();
+
+  /* Set a custom memory allocation function for the environment.  May ONLY
+   * be called before any calls to Malloc()/Realloc()/AddCleanup() below.
+   * If this is not called, the system realloc() function will be used.
+   * The given user pointer "ud" will be passed to the allocation function.
+   *
+   * The allocation function will not receive corresponding "free" calls.  it
+   * must ensure that the memory is valid for the lifetime of the Environment,
+   * but it may be reclaimed any time thereafter.  The likely usage is that
+   * "ud" points to a stateful allocator, and that the allocator frees all
+   * memory, arena-style, when it is destroyed.  In this case the allocator must
+   * outlive the Environment.  Another possibility is that the allocation
+   * function returns GC-able memory that is guaranteed to be GC-rooted for the
+   * life of the Environment. */
+  void SetAllocationFunction(upb_alloc_func* alloc, void* ud);
+
+  template<class T>
+  void SetAllocator(T* allocator) {
+    SetAllocationFunction(allocator->GetAllocationFunction(), allocator);
+  }
+
+  /* Set a custom error reporting function. */
+  void SetErrorFunction(upb_error_func* func, void* ud);
+
+  /* Set the error reporting function to simply copy the status to the given
+   * status and abort. */
+  void ReportErrorsTo(Status* status);
+
+  /* Returns true if all allocations and AddCleanup() calls have succeeded,
+   * and no errors were reported with ReportError() (except ones that recovered
+   * successfully). */
+  bool ok() const;
+
+  /* Functions for use by encoders/decoders. **********************************/
+
+  /* Reports an error to this environment's callback, returning true if
+   * the caller should try to recover. */
+  bool ReportError(const Status* status);
+
+  /* Allocate memory.  Uses the environment's allocation function.
+   *
+   * There is no need to free(). All memory will be freed automatically, but is
+   * guaranteed to outlive the Environment. */
+  void* Malloc(size_t size);
+
+  /* Reallocate memory.  Preserves "oldsize" bytes from the existing buffer
+   * Requires: oldsize <= existing_size.
+   *
+   * TODO(haberman): should we also enforce that oldsize <= size? */
+  void* Realloc(void* ptr, size_t oldsize, size_t size);
+
+  /* Add a cleanup function to run when the environment is destroyed.
+   * Returns false on out-of-memory.
+   *
+   * The first call to AddCleanup() after SetAllocationFunction() is guaranteed
+   * to return true -- this makes it possible to robustly set a cleanup handler
+   * for a custom allocation function. */
+  bool AddCleanup(upb_cleanup_func* func, void* ud);
+
+  /* Total number of bytes that have been allocated.  It is undefined what
+   * Realloc() does to this counter. */
+  size_t BytesAllocated() const;
+
+ private:
+  UPB_DISALLOW_COPY_AND_ASSIGN(Environment)
+
+#else
+struct upb_env {
+#endif  /* __cplusplus */
+
+  bool ok_;
+  size_t bytes_allocated;
+
+  /* Alloc function. */
+  upb_alloc_func *alloc;
+  void *alloc_ud;
+
+  /* Error-reporting function. */
+  upb_error_func *err;
+  void *err_ud;
+
+  /* Userdata for default alloc func. */
+  void *default_alloc_ud;
+
+  /* Cleanup entries.  Pointer to a cleanup_ent, defined in env.c */
+  void *cleanup_head;
+
+  /* For future expansion, since the size of this struct is exposed to users. */
+  void *future1;
+  void *future2;
+};
+
+UPB_BEGIN_EXTERN_C
+
+void upb_env_init(upb_env *e);
+void upb_env_uninit(upb_env *e);
+void upb_env_setallocfunc(upb_env *e, upb_alloc_func *func, void *ud);
+void upb_env_seterrorfunc(upb_env *e, upb_error_func *func, void *ud);
+void upb_env_reporterrorsto(upb_env *e, upb_status *status);
+bool upb_env_ok(const upb_env *e);
+bool upb_env_reporterror(upb_env *e, const upb_status *status);
+void *upb_env_malloc(upb_env *e, size_t size);
+void *upb_env_realloc(upb_env *e, void *ptr, size_t oldsize, size_t size);
+bool upb_env_addcleanup(upb_env *e, upb_cleanup_func *func, void *ud);
+size_t upb_env_bytesallocated(const upb_env *e);
+
+UPB_END_EXTERN_C
+
+#ifdef __cplusplus
+
+/* An allocator that allocates from an initial memory region (likely the stack)
+ * before falling back to another allocator. */
+class upb::SeededAllocator {
+ public:
+  SeededAllocator(void *mem, size_t len);
+  ~SeededAllocator();
+
+  /* Set a custom fallback memory allocation function for the allocator, to use
+   * once the initial region runs out.
+   *
+   * May ONLY be called before GetAllocationFunction().  If this is not
+   * called, the system realloc() will be the fallback allocator. */
+  void SetFallbackAllocator(upb_alloc_func *alloc, void *ud);
+
+  /* Gets the allocation function for this allocator. */
+  upb_alloc_func* GetAllocationFunction();
+
+ private:
+  UPB_DISALLOW_COPY_AND_ASSIGN(SeededAllocator)
+
+#else
+struct upb_seededalloc {
+#endif  /* __cplusplus */
+
+  /* Fallback alloc function.  */
+  upb_alloc_func *alloc;
+  upb_cleanup_func *alloc_cleanup;
+  void *alloc_ud;
+  bool need_cleanup;
+  bool returned_allocfunc;
+
+  /* Userdata for default alloc func. */
+  void *default_alloc_ud;
+
+  /* Pointers for the initial memory region. */
+  char *mem_base;
+  char *mem_ptr;
+  char *mem_limit;
+
+  /* For future expansion, since the size of this struct is exposed to users. */
+  void *future1;
+  void *future2;
+};
+
+UPB_BEGIN_EXTERN_C
+
+void upb_seededalloc_init(upb_seededalloc *a, void *mem, size_t len);
+void upb_seededalloc_uninit(upb_seededalloc *a);
+void upb_seededalloc_setfallbackalloc(upb_seededalloc *a, upb_alloc_func *func,
+                                      void *ud);
+upb_alloc_func *upb_seededalloc_getallocfunc(upb_seededalloc *a);
+
+UPB_END_EXTERN_C
+
+#ifdef __cplusplus
+
+namespace upb {
+
+inline Environment::Environment() {
+  upb_env_init(this);
+}
+inline Environment::~Environment() {
+  upb_env_uninit(this);
+}
+inline void Environment::SetAllocationFunction(upb_alloc_func *alloc,
+                                               void *ud) {
+  upb_env_setallocfunc(this, alloc, ud);
+}
+inline void Environment::SetErrorFunction(upb_error_func *func, void *ud) {
+  upb_env_seterrorfunc(this, func, ud);
+}
+inline void Environment::ReportErrorsTo(Status* status) {
+  upb_env_reporterrorsto(this, status);
+}
+inline bool Environment::ok() const {
+  return upb_env_ok(this);
+}
+inline bool Environment::ReportError(const Status* status) {
+  return upb_env_reporterror(this, status);
+}
+inline void *Environment::Malloc(size_t size) {
+  return upb_env_malloc(this, size);
+}
+inline void *Environment::Realloc(void *ptr, size_t oldsize, size_t size) {
+  return upb_env_realloc(this, ptr, oldsize, size);
+}
+inline bool Environment::AddCleanup(upb_cleanup_func *func, void *ud) {
+  return upb_env_addcleanup(this, func, ud);
+}
+inline size_t Environment::BytesAllocated() const {
+  return upb_env_bytesallocated(this);
+}
+
+inline SeededAllocator::SeededAllocator(void *mem, size_t len) {
+  upb_seededalloc_init(this, mem, len);
+}
+inline SeededAllocator::~SeededAllocator() {
+  upb_seededalloc_uninit(this);
+}
+inline void SeededAllocator::SetFallbackAllocator(upb_alloc_func *alloc,
+                                                  void *ud) {
+  upb_seededalloc_setfallbackalloc(this, alloc, ud);
+}
+inline upb_alloc_func *SeededAllocator::GetAllocationFunction() {
+  return upb_seededalloc_getallocfunc(this);
+}
+
+}  /* namespace upb */
+
+#endif  /* __cplusplus */
+
+#endif  /* UPB_ENV_H_ */
+/*
 ** upb::Sink (upb_sink)
 ** upb::BytesSink (upb_bytessink)
 **
 ** A upb_sink is an object that binds a upb_handlers object to some runtime
 ** state.  It is the object that can actually receive data via the upb_handlers
 ** interface.
 **
 ** Unlike upb_def and upb_handlers, upb_sink is never frozen, immutable, or
 ** thread-safe.  You can create as many of them as you want, but each one may
 ** only be used in a single thread at a time.
@@ skipping 683 matching lines @@
    * leave the defs themselves partially resolved.  Does this matter?  If so we
    * could do a prepass that ensures that all symbols are resolvable and bail
    * if not, so we don't mutate anything until we know the operation will
    * succeed.
    *
    * TODO(haberman): since the defs must be mutable, refining a frozen def
    * requires making mutable copies of the entire tree.  This is wasteful if
    * only a few messages are changing.  We may want to add a way of adding a
    * tree of frozen defs to the symtab (perhaps an alternate constructor where
    * you pass the root of the tree?) */
-  bool Add(Def*const* defs, size_t n, void* ref_donor, Status* status);
+  bool Add(Def*const* defs, int n, void* ref_donor, upb_status* status);
 
   bool Add(const std::vector<Def*>& defs, void *owner, Status* status) {
     return Add((Def*const*)&defs[0], defs.size(), owner, status);
   }
 
-  /* Resolves all subdefs for messages in this file and attempts to freeze the
-   * file.  If this succeeds, adds all the symbols to this SymbolTable
-   * (replacing any existing ones with the same names). */
-  bool AddFile(FileDef* file, Status* s);
-
  private:
   UPB_DISALLOW_POD_OPS(SymbolTable, upb::SymbolTable)
 };
 
 #endif  /* __cplusplus */
 
 UPB_BEGIN_EXTERN_C
 
 /* Native C API. */
 
 /* Include refcounted methods like upb_symtab_ref(). */
 UPB_REFCOUNTED_CMETHODS(upb_symtab, upb_symtab_upcast)
 
 upb_symtab *upb_symtab_new(const void *owner);
 void upb_symtab_freeze(upb_symtab *s);
 const upb_def *upb_symtab_resolve(const upb_symtab *s, const char *base,
                                   const char *sym);
 const upb_def *upb_symtab_lookup(const upb_symtab *s, const char *sym);
 const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym);
 const upb_enumdef *upb_symtab_lookupenum(const upb_symtab *s, const char *sym);
-bool upb_symtab_add(upb_symtab *s, upb_def *const*defs, size_t n,
-                    void *ref_donor, upb_status *status);
-bool upb_symtab_addfile(upb_symtab *s, upb_filedef *file, upb_status* status);
+bool upb_symtab_add(upb_symtab *s, upb_def *const*defs, int n, void *ref_donor,
+                    upb_status *status);
 
 /* upb_symtab_iter i;
  * for(upb_symtab_begin(&i, s, type); !upb_symtab_done(&i);
  *     upb_symtab_next(&i)) {
  *   const upb_def *def = upb_symtab_iter_def(&i);
  *    // ...
  * }
  *
  * For C we don't have separate iterators for const and non-const.
  * It is the caller's responsibility to cast the upb_fielddef* to
@@ skipping 21 matching lines @@
                                        const char *sym) const {
   return upb_symtab_resolve(this, base, sym);
 }
 inline const Def* SymbolTable::Lookup(const char *sym) const {
   return upb_symtab_lookup(this, sym);
 }
 inline const MessageDef *SymbolTable::LookupMessage(const char *sym) const {
   return upb_symtab_lookupmsg(this, sym);
 }
 inline bool SymbolTable::Add(
-    Def*const* defs, size_t n, void* ref_donor, Status* status) {
+    Def*const* defs, int n, void* ref_donor, upb_status* status) {
   return upb_symtab_add(this, (upb_def*const*)defs, n, ref_donor, status);
 }
-inline bool SymbolTable::AddFile(FileDef* file, Status* s) {
-  return upb_symtab_addfile(this, file, s);
-}
 }  /* namespace upb */
 #endif
 
 #endif  /* UPB_SYMTAB_H_ */
 /*
 ** upb::descriptor::Reader (upb_descreader)
 **
 ** Provides a way of building upb::Defs from data in descriptor.proto format.
 */
 
@@ skipping 23 matching lines @@
    * TODO: generate the handlers statically (like we do with the
    * descriptor.proto defs) so that there is no need to pass this parameter (or
    * to build/memory-manage the handlers at runtime at all).  Unfortunately this
    * is a bit tricky to implement for Handlers, but necessary to simplify this
    * interface. */
   static Reader* Create(Environment* env, const Handlers* handlers);
 
   /* The reader's input; this is where descriptor.proto data should be sent. */
   Sink* input();
 
-  /* Use to get the FileDefs that have been parsed. */
-  size_t file_count() const;
-  FileDef* file(size_t i) const;
+  /* Returns an array of all defs that have been parsed, and transfers ownership
+   * of them to "owner".  The number of defs is stored in *n.  Ownership of the
+   * returned array is retained and is invalidated by any other call into
+   * Reader.
+   *
+   * These defs are not frozen or resolved; they are ready to be added to a
+   * symtab. */
+  upb::Def** GetDefs(void* owner, int* n);
 
   /* Builds and returns handlers for the reader, owned by "owner." */
   static Handlers* NewHandlers(const void* owner);
 
  private:
   UPB_DISALLOW_POD_OPS(Reader, upb::descriptor::Reader)
 };
 
 #endif
 
 UPB_BEGIN_EXTERN_C
 
 /* C API. */
 upb_descreader *upb_descreader_create(upb_env *e, const upb_handlers *h);
 upb_sink *upb_descreader_input(upb_descreader *r);
-size_t upb_descreader_filecount(const upb_descreader *r);
-upb_filedef *upb_descreader_file(const upb_descreader *r, size_t i);
+upb_def **upb_descreader_getdefs(upb_descreader *r, void *owner, int *n);
 const upb_handlers *upb_descreader_newhandlers(const void *owner);
 
 UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 /* C++ implementation details. ************************************************/
 namespace upb {
 namespace descriptor {
 inline Reader* Reader::Create(Environment* e, const Handlers *h) {
   return upb_descreader_create(e, h);
 }
 inline Sink* Reader::input() { return upb_descreader_input(this); }
-inline size_t Reader::file_count() const {
-  return upb_descreader_filecount(this);
-}
-inline FileDef* Reader::file(size_t i) const {
-  return upb_descreader_file(this, i);
+inline upb::Def** Reader::GetDefs(void* owner, int* n) {
+  return upb_descreader_getdefs(this, owner, n);
 }
 }  /* namespace descriptor */
 }  /* namespace upb */
 #endif
 
 #endif  /* UPB_DESCRIPTOR_H */
 /* This file contains accessors for a set of compiled-in defs.
  * Note that unlike Google's protobuf, it does *not* define
  * generated classes or any other kind of data structure for
  * actually storing protobufs.  It only contains *defs* which
  * let you reflect over a protobuf *schema*.
  */
-/* This file was generated by upbc (the upb compiler) from the input
- * file:
- *
- *     upb/descriptor/descriptor.proto
- *
+/* This file was generated by upbc (the upb compiler).
  * Do not edit -- your changes will be discarded when the file is
  * regenerated. */
 
-#ifndef UPB_DESCRIPTOR_DESCRIPTOR_PROTO_UPB_H_
-#define UPB_DESCRIPTOR_DESCRIPTOR_PROTO_UPB_H_
-
-
+#ifndef GOOGLE_PROTOBUF_DESCRIPTOR_UPB_H_
+#define GOOGLE_PROTOBUF_DESCRIPTOR_UPB_H_
+
+
+#ifdef __cplusplus
 UPB_BEGIN_EXTERN_C
+#endif
 
 /* Enums */
 
 typedef enum {
-  google_protobuf_FieldDescriptorProto_LABEL_OPTIONAL = 1,
-  google_protobuf_FieldDescriptorProto_LABEL_REQUIRED = 2,
-  google_protobuf_FieldDescriptorProto_LABEL_REPEATED = 3
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_OPTIONAL = 1,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_REQUIRED = 2,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_REPEATED = 3
 } google_protobuf_FieldDescriptorProto_Label;
 
 typedef enum {
-  google_protobuf_FieldDescriptorProto_TYPE_DOUBLE = 1,
-  google_protobuf_FieldDescriptorProto_TYPE_FLOAT = 2,
-  google_protobuf_FieldDescriptorProto_TYPE_INT64 = 3,
-  google_protobuf_FieldDescriptorProto_TYPE_UINT64 = 4,
-  google_protobuf_FieldDescriptorProto_TYPE_INT32 = 5,
-  google_protobuf_FieldDescriptorProto_TYPE_FIXED64 = 6,
-  google_protobuf_FieldDescriptorProto_TYPE_FIXED32 = 7,
-  google_protobuf_FieldDescriptorProto_TYPE_BOOL = 8,
-  google_protobuf_FieldDescriptorProto_TYPE_STRING = 9,
-  google_protobuf_FieldDescriptorProto_TYPE_GROUP = 10,
-  google_protobuf_FieldDescriptorProto_TYPE_MESSAGE = 11,
-  google_protobuf_FieldDescriptorProto_TYPE_BYTES = 12,
-  google_protobuf_FieldDescriptorProto_TYPE_UINT32 = 13,
-  google_protobuf_FieldDescriptorProto_TYPE_ENUM = 14,
-  google_protobuf_FieldDescriptorProto_TYPE_SFIXED32 = 15,
-  google_protobuf_FieldDescriptorProto_TYPE_SFIXED64 = 16,
-  google_protobuf_FieldDescriptorProto_TYPE_SINT32 = 17,
-  google_protobuf_FieldDescriptorProto_TYPE_SINT64 = 18
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_DOUBLE = 1,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_FLOAT = 2,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_INT64 = 3,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_UINT64 = 4,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_INT32 = 5,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_FIXED64 = 6,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_FIXED32 = 7,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_BOOL = 8,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_STRING = 9,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_GROUP = 10,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_MESSAGE = 11,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_BYTES = 12,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_UINT32 = 13,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_ENUM = 14,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_SFIXED32 = 15,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_SFIXED64 = 16,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_SINT32 = 17,
+  GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_SINT64 = 18
 } google_protobuf_FieldDescriptorProto_Type;
 
 typedef enum {
-  google_protobuf_FieldOptions_STRING = 0,
-  google_protobuf_FieldOptions_CORD = 1,
-  google_protobuf_FieldOptions_STRING_PIECE = 2
+  GOOGLE_PROTOBUF_FIELDOPTIONS_STRING = 0,
+  GOOGLE_PROTOBUF_FIELDOPTIONS_CORD = 1,
+  GOOGLE_PROTOBUF_FIELDOPTIONS_STRING_PIECE = 2
 } google_protobuf_FieldOptions_CType;
 
 typedef enum {
-  google_protobuf_FieldOptions_JS_NORMAL = 0,
-  google_protobuf_FieldOptions_JS_STRING = 1,
-  google_protobuf_FieldOptions_JS_NUMBER = 2
-} google_protobuf_FieldOptions_JSType;
-
-typedef enum {
-  google_protobuf_FileOptions_SPEED = 1,
-  google_protobuf_FileOptions_CODE_SIZE = 2,
-  google_protobuf_FileOptions_LITE_RUNTIME = 3
+  GOOGLE_PROTOBUF_FILEOPTIONS_SPEED = 1,
+  GOOGLE_PROTOBUF_FILEOPTIONS_CODE_SIZE = 2,
+  GOOGLE_PROTOBUF_FILEOPTIONS_LITE_RUNTIME = 3
 } google_protobuf_FileOptions_OptimizeMode;
 
-/* MessageDefs: call these functions to get a ref to a msgdef. */
-const upb_msgdef *upbdefs_google_protobuf_DescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_DescriptorProto_ExtensionRange_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_DescriptorProto_ReservedRange_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_EnumDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_EnumOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_EnumValueDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_EnumValueOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_FieldDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_FieldOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_FileDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_FileDescriptorSet_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_FileOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_MessageOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_MethodDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_MethodOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_OneofDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_ServiceDescriptorProto_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_ServiceOptions_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_SourceCodeInfo_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_SourceCodeInfo_Location_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_UninterpretedOption_get(const void *owner);
-const upb_msgdef *upbdefs_google_protobuf_UninterpretedOption_NamePart_get(const void *owner);
-
-/* EnumDefs: call these functions to get a ref to an enumdef. */
-const upb_enumdef *upbdefs_google_protobuf_FieldDescriptorProto_Label_get(const void *owner);
-const upb_enumdef *upbdefs_google_protobuf_FieldDescriptorProto_Type_get(const void *owner);
-const upb_enumdef *upbdefs_google_protobuf_FieldOptions_CType_get(const void *owner);
-const upb_enumdef *upbdefs_google_protobuf_FieldOptions_JSType_get(const void *owner);
-const upb_enumdef *upbdefs_google_protobuf_FileOptions_OptimizeMode_get(const void *owner);
-
-/* Functions to test whether this message is of a certain type. */
-UPB_INLINE bool upbdefs_google_protobuf_DescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.DescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_DescriptorProto_ExtensionRange_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.DescriptorProto.ExtensionRange") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_DescriptorProto_ReservedRange_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.DescriptorProto.ReservedRange") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_EnumDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.EnumDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_EnumOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.EnumOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_EnumValueDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.EnumValueDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_EnumValueOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.EnumValueOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FieldDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.FieldDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FieldOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.FieldOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FileDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.FileDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FileDescriptorSet_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.FileDescriptorSet") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FileOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.FileOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_MessageOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.MessageOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_MethodDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.MethodDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_MethodOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.MethodOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_OneofDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.OneofDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_ServiceDescriptorProto_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.ServiceDescriptorProto") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_ServiceOptions_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.ServiceOptions") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_SourceCodeInfo_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.SourceCodeInfo") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_SourceCodeInfo_Location_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.SourceCodeInfo.Location") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_UninterpretedOption_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.UninterpretedOption") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_UninterpretedOption_NamePart_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "google.protobuf.UninterpretedOption.NamePart") == 0;
-}
-
-/* Functions to test whether this enum is of a certain type. */
-UPB_INLINE bool upbdefs_google_protobuf_FieldDescriptorProto_Label_is(const upb_enumdef *e) {
-  return strcmp(upb_enumdef_fullname(e), "google.protobuf.FieldDescriptorProto.Label") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FieldDescriptorProto_Type_is(const upb_enumdef *e) {
-  return strcmp(upb_enumdef_fullname(e), "google.protobuf.FieldDescriptorProto.Type") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FieldOptions_CType_is(const upb_enumdef *e) {
-  return strcmp(upb_enumdef_fullname(e), "google.protobuf.FieldOptions.CType") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FieldOptions_JSType_is(const upb_enumdef *e) {
-  return strcmp(upb_enumdef_fullname(e), "google.protobuf.FieldOptions.JSType") == 0;
-}
-UPB_INLINE bool upbdefs_google_protobuf_FileOptions_OptimizeMode_is(const upb_enumdef *e) {
-  return strcmp(upb_enumdef_fullname(e), "google.protobuf.FileOptions.OptimizeMode") == 0;
-}
-
-
-/* Functions to get a fielddef from a msgdef reference. */
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_ExtensionRange_f_end(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ExtensionRange_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_ExtensionRange_f_start(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ExtensionRange_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_ReservedRange_f_end(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ReservedRange_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_ReservedRange_f_start(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ReservedRange_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_enum_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_extension(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_extension_range(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_field(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_nested_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_oneof_decl(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 8); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 7); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_reserved_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 10); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_f_reserved_range(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m)); return upb_msgdef_itof(m, 9); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumDescriptorProto_f_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumOptions_f_allow_alias(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumOptions_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumOptions_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumValueDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueDescriptorProto_f_number(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumValueDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumValueDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumValueOptions_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_EnumValueOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_default_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 7); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_extendee(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_json_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 10); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_label(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_number(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_oneof_index(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 9); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 8); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_f_type_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_ctype(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_jstype(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_lazy(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_packed(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_f_weak(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m)); return upb_msgdef_itof(m, 10); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_dependency(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_enum_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_extension(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 7); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_message_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 8); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_package(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_public_dependency(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 10); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_service(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_source_code_info(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 9); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_syntax(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 12); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_f_weak_dependency(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m)); return upb_msgdef_itof(m, 11); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorSet_f_file(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorSet_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_cc_enable_arenas(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 31); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_cc_generic_services(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 16); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_csharp_namespace(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 37); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 23); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_go_package(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 11); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_generate_equals_and_hash(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 20); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_generic_services(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 17); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_multiple_files(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 10); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_outer_classname(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 8); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_package(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_java_string_check_utf8(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 27); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_javanano_use_deprecated_package(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 38); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_objc_class_prefix(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 36); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_optimize_for(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 9); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_py_generic_services(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 18); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_f_map_entry(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m)); return upb_msgdef_itof(m, 7); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_f_message_set_wire_format(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_f_no_standard_descriptor_accessor(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_client_streaming(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_input_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_output_type(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_f_server_streaming(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodOptions_is(m)); return upb_msgdef_itof(m, 33); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_MethodOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_OneofDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_OneofDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceDescriptorProto_f_method(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_ServiceDescriptorProto_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceDescriptorProto_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_ServiceDescriptorProto_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceDescriptorProto_f_options(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_ServiceDescriptorProto_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceOptions_f_deprecated(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_ServiceOptions_is(m)); return upb_msgdef_itof(m, 33); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceOptions_f_uninterpreted_option(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_ServiceOptions_is(m)); return upb_msgdef_itof(m, 999); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_f_leading_comments(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_f_leading_detached_comments(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_f_path(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_f_span(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_f_trailing_comments(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_f_location(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_NamePart_f_is_extension(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_NamePart_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_NamePart_f_name_part(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_NamePart_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_aggregate_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 8); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_double_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_identifier_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_name(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_negative_int_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_positive_int_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_f_string_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m)); return upb_msgdef_itof(m, 7); }
+/* Selectors */
+
+/* google.protobuf.DescriptorProto */
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_FIELD_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NESTED_TYPE_STARTSUBMSG 3
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_ENUM_TYPE_STARTSUBMSG 4
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_RANGE_STARTSUBMSG 5
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_STARTSUBMSG 6
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_OPTIONS_STARTSUBMSG 7
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_FIELD_STARTSEQ 8
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_FIELD_ENDSEQ 9
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_FIELD_ENDSUBMSG 10
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NESTED_TYPE_STARTSEQ 11
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NESTED_TYPE_ENDSEQ 12
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NESTED_TYPE_ENDSUBMSG 13
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_ENUM_TYPE_STARTSEQ 14
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_ENUM_TYPE_ENDSEQ 15
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_ENUM_TYPE_ENDSUBMSG 16
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_RANGE_STARTSEQ 17
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_RANGE_ENDSEQ 18
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_RANGE_ENDSUBMSG 19
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_STARTSEQ 20
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_ENDSEQ 21
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_ENDSUBMSG 22
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_OPTIONS_ENDSUBMSG 23
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NAME_STRING 24
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NAME_STARTSTR 25
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NAME_ENDSTR 26
+
+/* google.protobuf.DescriptorProto.ExtensionRange */
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSIONRANGE_START_INT32 2
+#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSIONRANGE_END_INT32 3
+
+/* google.protobuf.EnumDescriptorProto */
+#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_VALUE_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 3
+#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_VALUE_STARTSEQ 4
+#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_VALUE_ENDSEQ 5
+#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_VALUE_ENDSUBMSG 6
+#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 7
+#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_NAME_STRING 8
+#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_NAME_STARTSTR 9
+#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_NAME_ENDSTR 10
+
+/* google.protobuf.EnumOptions */
+#define SEL_GOOGLE_PROTOBUF_ENUMOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_ENUMOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
+#define SEL_GOOGLE_PROTOBUF_ENUMOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
+#define SEL_GOOGLE_PROTOBUF_ENUMOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
+#define SEL_GOOGLE_PROTOBUF_ENUMOPTIONS_ALLOW_ALIAS_BOOL 6
+
+/* google.protobuf.EnumValueDescriptorProto */
+#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 3
+#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NAME_STRING 4
+#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NAME_STARTSTR 5
+#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NAME_ENDSTR 6
+#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NUMBER_INT32 7
+
+/* google.protobuf.EnumValueOptions */
+#define SEL_GOOGLE_PROTOBUF_ENUMVALUEOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_ENUMVALUEOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
+#define SEL_GOOGLE_PROTOBUF_ENUMVALUEOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
+#define SEL_GOOGLE_PROTOBUF_ENUMVALUEOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
+
+/* google.protobuf.FieldDescriptorProto */
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 3
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NAME_STRING 4
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NAME_STARTSTR 5
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NAME_ENDSTR 6
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_EXTENDEE_STRING 7
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_EXTENDEE_STARTSTR 8
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_EXTENDEE_ENDSTR 9
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NUMBER_INT32 10
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_INT32 11
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_INT32 12
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_NAME_STRING 13
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_NAME_STARTSTR 14
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_NAME_ENDSTR 15
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_DEFAULT_VALUE_STRING 16
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_DEFAULT_VALUE_STARTSTR 17
+#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_DEFAULT_VALUE_ENDSTR 18
+
+/* google.protobuf.FieldOptions */
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_CTYPE_INT32 6
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_PACKED_BOOL 7
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_DEPRECATED_BOOL 8
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_LAZY_BOOL 9
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_EXPERIMENTAL_MAP_KEY_STRING 10
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_EXPERIMENTAL_MAP_KEY_STARTSTR 11
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_EXPERIMENTAL_MAP_KEY_ENDSTR 12
+#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_WEAK_BOOL 13
+
+/* google.protobuf.FileDescriptorProto */
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_MESSAGE_TYPE_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ENUM_TYPE_STARTSUBMSG 3
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SERVICE_STARTSUBMSG 4
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_EXTENSION_STARTSUBMSG 5
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 6
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SOURCE_CODE_INFO_STARTSUBMSG 7
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_MESSAGE_TYPE_STARTSEQ 8
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_MESSAGE_TYPE_ENDSEQ 9
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_MESSAGE_TYPE_ENDSUBMSG 10
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ENUM_TYPE_STARTSEQ 11
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ENUM_TYPE_ENDSEQ 12
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ENUM_TYPE_ENDSUBMSG 13
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SERVICE_STARTSEQ 14
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SERVICE_ENDSEQ 15
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SERVICE_ENDSUBMSG 16
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_EXTENSION_STARTSEQ 17
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_EXTENSION_ENDSEQ 18
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_EXTENSION_ENDSUBMSG 19
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 20
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SOURCE_CODE_INFO_ENDSUBMSG 21
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_NAME_STRING 22
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_NAME_STARTSTR 23
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_NAME_ENDSTR 24
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PACKAGE_STRING 25
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PACKAGE_STARTSTR 26
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PACKAGE_ENDSTR 27
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_DEPENDENCY_STARTSEQ 28
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_DEPENDENCY_ENDSEQ 29
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_DEPENDENCY_STRING 30
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_DEPENDENCY_STARTSTR 31
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_DEPENDENCY_ENDSTR 32
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PUBLIC_DEPENDENCY_STARTSEQ 33
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PUBLIC_DEPENDENCY_ENDSEQ 34
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PUBLIC_DEPENDENCY_INT32 35
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_WEAK_DEPENDENCY_STARTSEQ 36
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_WEAK_DEPENDENCY_ENDSEQ 37
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_WEAK_DEPENDENCY_INT32 38
+
+/* google.protobuf.FileDescriptorSet */
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORSET_FILE_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORSET_FILE_STARTSEQ 3
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORSET_FILE_ENDSEQ 4
+#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORSET_FILE_ENDSUBMSG 5
+
+/* google.protobuf.FileOptions */
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_PACKAGE_STRING 6
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_PACKAGE_STARTSTR 7
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_PACKAGE_ENDSTR 8
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_OUTER_CLASSNAME_STRING 9
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_OUTER_CLASSNAME_STARTSTR 10
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_OUTER_CLASSNAME_ENDSTR 11
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_OPTIMIZE_FOR_INT32 12
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_MULTIPLE_FILES_BOOL 13
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_GO_PACKAGE_STRING 14
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_GO_PACKAGE_STARTSTR 15
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_GO_PACKAGE_ENDSTR 16
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_CC_GENERIC_SERVICES_BOOL 17
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_GENERIC_SERVICES_BOOL 18
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_PY_GENERIC_SERVICES_BOOL 19
+#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_GENERATE_EQUALS_AND_HASH_BOOL 20
+
+/* google.protobuf.MessageOptions */
+#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
+#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
+#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
+#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_MESSAGE_SET_WIRE_FORMAT_BOOL 6
+#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_NO_STANDARD_DESCRIPTOR_ACCESSOR_BOOL 7
+
+/* google.protobuf.MethodDescriptorProto */
+#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 3
+#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_NAME_STRING 4
+#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_NAME_STARTSTR 5
+#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_NAME_ENDSTR 6
+#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_INPUT_TYPE_STRING 7
+#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_INPUT_TYPE_STARTSTR 8
+#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_INPUT_TYPE_ENDSTR 9
+#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_OUTPUT_TYPE_STRING 10
+#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_OUTPUT_TYPE_STARTSTR 11
+#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_OUTPUT_TYPE_ENDSTR 12
+
+/* google.protobuf.MethodOptions */
+#define SEL_GOOGLE_PROTOBUF_METHODOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_METHODOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
+#define SEL_GOOGLE_PROTOBUF_METHODOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
+#define SEL_GOOGLE_PROTOBUF_METHODOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
+
+/* google.protobuf.ServiceDescriptorProto */
+#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_METHOD_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 3
+#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_METHOD_STARTSEQ 4
+#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_METHOD_ENDSEQ 5
+#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_METHOD_ENDSUBMSG 6
+#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 7
+#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_NAME_STRING 8
+#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_NAME_STARTSTR 9
+#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_NAME_ENDSTR 10
+
+/* google.protobuf.ServiceOptions */
+#define SEL_GOOGLE_PROTOBUF_SERVICEOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_SERVICEOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
+#define SEL_GOOGLE_PROTOBUF_SERVICEOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
+#define SEL_GOOGLE_PROTOBUF_SERVICEOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
+
+/* google.protobuf.SourceCodeInfo */
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_STARTSEQ 3
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_ENDSEQ 4
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_ENDSUBMSG 5
+
+/* google.protobuf.SourceCodeInfo.Location */
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_PATH_STARTSEQ 2
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_PATH_ENDSEQ 3
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_PATH_INT32 4
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_SPAN_STARTSEQ 5
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_SPAN_ENDSEQ 6
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_SPAN_INT32 7
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_LEADING_COMMENTS_STRING 8
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_LEADING_COMMENTS_STARTSTR 9
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_LEADING_COMMENTS_ENDSTR 10
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_TRAILING_COMMENTS_STRING 11
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_TRAILING_COMMENTS_STARTSTR 12
+#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_TRAILING_COMMENTS_ENDSTR 13
+
+/* google.protobuf.UninterpretedOption */
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAME_STARTSUBMSG 2
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAME_STARTSEQ 3
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAME_ENDSEQ 4
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAME_ENDSUBMSG 5
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_IDENTIFIER_VALUE_STRING 6
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_IDENTIFIER_VALUE_STARTSTR 7
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_IDENTIFIER_VALUE_ENDSTR 8
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_POSITIVE_INT_VALUE_UINT64 9
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NEGATIVE_INT_VALUE_INT64 10
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_DOUBLE_VALUE_DOUBLE 11
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_STRING_VALUE_STRING 12
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_STRING_VALUE_STARTSTR 13
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_STRING_VALUE_ENDSTR 14
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_AGGREGATE_VALUE_STRING 15
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_AGGREGATE_VALUE_STARTSTR 16
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_AGGREGATE_VALUE_ENDSTR 17
+
+/* google.protobuf.UninterpretedOption.NamePart */
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAMEPART_NAME_PART_STRING 2
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAMEPART_NAME_PART_STARTSTR 3
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAMEPART_NAME_PART_ENDSTR 4
+#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAMEPART_IS_EXTENSION_BOOL 5
+
+const upb_symtab *upbdefs_google_protobuf_descriptor(const void *owner);
+
+/* MessageDefs */
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_DescriptorProto(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.DescriptorProto");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_DescriptorProto_ExtensionRange(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.DescriptorProto.ExtensionRange");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_EnumDescriptorProto(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.EnumDescriptorProto");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_EnumOptions(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.EnumOptions");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_EnumValueDescriptorProto(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.EnumValueDescriptorProto");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_EnumValueOptions(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.EnumValueOptions");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_FieldDescriptorProto(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.FieldDescriptorProto");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_FieldOptions(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.FieldOptions");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_FileDescriptorProto(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.FileDescriptorProto");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_FileDescriptorSet(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.FileDescriptorSet");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_FileOptions(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.FileOptions");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_MessageOptions(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.MessageOptions");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_MethodDescriptorProto(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.MethodDescriptorProto");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_MethodOptions(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.MethodOptions");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_ServiceDescriptorProto(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.ServiceDescriptorProto");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_ServiceOptions(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.ServiceOptions");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_SourceCodeInfo(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.SourceCodeInfo");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_SourceCodeInfo_Location(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.SourceCodeInfo.Location");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_UninterpretedOption(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.UninterpretedOption");
+  assert(m);
+  return m;
+}
+UPB_INLINE const upb_msgdef *upbdefs_google_protobuf_UninterpretedOption_NamePart(const upb_symtab *s) {
+  const upb_msgdef *m = upb_symtab_lookupmsg(s, "google.protobuf.UninterpretedOption.NamePart");
+  assert(m);
+  return m;
+}
+
+
+/* EnumDefs */
+UPB_INLINE const upb_enumdef *upbdefs_google_protobuf_FieldDescriptorProto_Label(const upb_symtab *s) {
+  const upb_enumdef *e = upb_symtab_lookupenum(s, "google.protobuf.FieldDescriptorProto.Label");
+  assert(e);
+  return e;
+}
+UPB_INLINE const upb_enumdef *upbdefs_google_protobuf_FieldDescriptorProto_Type(const upb_symtab *s) {
+  const upb_enumdef *e = upb_symtab_lookupenum(s, "google.protobuf.FieldDescriptorProto.Type");
+  assert(e);
+  return e;
+}
+UPB_INLINE const upb_enumdef *upbdefs_google_protobuf_FieldOptions_CType(const upb_symtab *s) {
+  const upb_enumdef *e = upb_symtab_lookupenum(s, "google.protobuf.FieldOptions.CType");
+  assert(e);
+  return e;
+}
+UPB_INLINE const upb_enumdef *upbdefs_google_protobuf_FileOptions_OptimizeMode(const upb_symtab *s) {
+  const upb_enumdef *e = upb_symtab_lookupenum(s, "google.protobuf.FileOptions.OptimizeMode");
+  assert(e);
+  return e;
+}
+
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_ExtensionRange_end(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_DescriptorProto_ExtensionRange(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_ExtensionRange_start(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_DescriptorProto_ExtensionRange(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_enum_type(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_DescriptorProto(s), 4); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_extension(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_DescriptorProto(s), 6); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_extension_range(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_DescriptorProto(s), 5); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_field(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_DescriptorProto(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_name(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_DescriptorProto(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_nested_type(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_DescriptorProto(s), 3); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_DescriptorProto_options(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_DescriptorProto(s), 7); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumDescriptorProto_name(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_EnumDescriptorProto(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumDescriptorProto_options(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_EnumDescriptorProto(s), 3); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumDescriptorProto_value(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_EnumDescriptorProto(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumOptions_allow_alias(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_EnumOptions(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumOptions_uninterpreted_option(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_EnumOptions(s), 999); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueDescriptorProto_name(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_EnumValueDescriptorProto(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueDescriptorProto_number(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_EnumValueDescriptorProto(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueDescriptorProto_options(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_EnumValueDescriptorProto(s), 3); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_EnumValueOptions_uninterpreted_option(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_EnumValueOptions(s), 999); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_default_value(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldDescriptorProto(s), 7); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_extendee(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldDescriptorProto(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_label(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldDescriptorProto(s), 4); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_name(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldDescriptorProto(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_number(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldDescriptorProto(s), 3); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_options(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldDescriptorProto(s), 8); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_type(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldDescriptorProto(s), 5); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldDescriptorProto_type_name(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldDescriptorProto(s), 6); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_ctype(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldOptions(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_deprecated(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldOptions(s), 3); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_experimental_map_key(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldOptions(s), 9); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_lazy(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldOptions(s), 5); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_packed(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldOptions(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_uninterpreted_option(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldOptions(s), 999); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FieldOptions_weak(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FieldOptions(s), 10); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_dependency(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorProto(s), 3); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_enum_type(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorProto(s), 5); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_extension(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorProto(s), 7); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_message_type(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorProto(s), 4); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_name(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorProto(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_options(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorProto(s), 8); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_package(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorProto(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_public_dependency(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorProto(s), 10); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_service(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorProto(s), 6); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_source_code_info(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorProto(s), 9); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorProto_weak_dependency(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorProto(s), 11); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileDescriptorSet_file(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileDescriptorSet(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_cc_generic_services(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileOptions(s), 16); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_go_package(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileOptions(s), 11); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_java_generate_equals_and_hash(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileOptions(s), 20); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_java_generic_services(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileOptions(s), 17); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_java_multiple_files(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileOptions(s), 10); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_java_outer_classname(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileOptions(s), 8); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_java_package(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileOptions(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_optimize_for(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileOptions(s), 9); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_py_generic_services(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileOptions(s), 18); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_FileOptions_uninterpreted_option(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_FileOptions(s), 999); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_message_set_wire_format(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_MessageOptions(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_no_standard_descriptor_accessor(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_MessageOptions(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MessageOptions_uninterpreted_option(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_MessageOptions(s), 999); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_input_type(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_MethodDescriptorProto(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_name(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_MethodDescriptorProto(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_options(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_MethodDescriptorProto(s), 4); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodDescriptorProto_output_type(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_MethodDescriptorProto(s), 3); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_MethodOptions_uninterpreted_option(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_MethodOptions(s), 999); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceDescriptorProto_method(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_ServiceDescriptorProto(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceDescriptorProto_name(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_ServiceDescriptorProto(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceDescriptorProto_options(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_ServiceDescriptorProto(s), 3); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_ServiceOptions_uninterpreted_option(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_ServiceOptions(s), 999); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_leading_comments(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_SourceCodeInfo_Location(s), 3); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_path(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_SourceCodeInfo_Location(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_span(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_SourceCodeInfo_Location(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_Location_trailing_comments(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_SourceCodeInfo_Location(s), 4); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_SourceCodeInfo_location(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_SourceCodeInfo(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_NamePart_is_extension(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_UninterpretedOption_NamePart(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_NamePart_name_part(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_UninterpretedOption_NamePart(s), 1); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_aggregate_value(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_UninterpretedOption(s), 8); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_double_value(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_UninterpretedOption(s), 6); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_identifier_value(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_UninterpretedOption(s), 3); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_name(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_UninterpretedOption(s), 2); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_negative_int_value(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_UninterpretedOption(s), 5); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_positive_int_value(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_UninterpretedOption(s), 4); }
+UPB_INLINE const upb_fielddef *upbdefs_google_protobuf_UninterpretedOption_string_value(const upb_symtab *s) { return upb_msgdef_itof(upbdefs_google_protobuf_UninterpretedOption(s), 7); }
 
 UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 
 namespace upbdefs {
 namespace google {
 namespace protobuf {
-
-class DescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  DescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_is(m));
-  }
-
-  static DescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_DescriptorProto_get(&m);
-    return DescriptorProto(m, &m);
-  }
-
-  class ExtensionRange : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    ExtensionRange(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ExtensionRange_is(m));
-    }
-
-    static ExtensionRange get() {
-      const ::upb::MessageDef* m = upbdefs_google_protobuf_DescriptorProto_ExtensionRange_get(&m);
-      return ExtensionRange(m, &m);
-    }
-  };
-
-  class ReservedRange : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    ReservedRange(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_DescriptorProto_ReservedRange_is(m));
-    }
-
-    static ReservedRange get() {
-      const ::upb::MessageDef* m = upbdefs_google_protobuf_DescriptorProto_ReservedRange_get(&m);
-      return ReservedRange(m, &m);
-    }
-  };
-};
-
-class EnumDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  EnumDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_EnumDescriptorProto_is(m));
-  }
-
-  static EnumDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_EnumDescriptorProto_get(&m);
-    return EnumDescriptorProto(m, &m);
-  }
-};
-
-class EnumOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  EnumOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_EnumOptions_is(m));
-  }
-
-  static EnumOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_EnumOptions_get(&m);
-    return EnumOptions(m, &m);
-  }
-};
-
-class EnumValueDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  EnumValueDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_EnumValueDescriptorProto_is(m));
-  }
-
-  static EnumValueDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_EnumValueDescriptorProto_get(&m);
-    return EnumValueDescriptorProto(m, &m);
-  }
-};
-
-class EnumValueOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  EnumValueOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_EnumValueOptions_is(m));
-  }
-
-  static EnumValueOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_EnumValueOptions_get(&m);
-    return EnumValueOptions(m, &m);
-  }
-};
-
-class FieldDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  FieldDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_is(m));
-  }
-
-  static FieldDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_FieldDescriptorProto_get(&m);
-    return FieldDescriptorProto(m, &m);
-  }
-
-  class Label : public ::upb::reffed_ptr<const ::upb::EnumDef> {
-   public:
-    Label(const ::upb::EnumDef* e, const void *ref_donor = NULL)
-        : reffed_ptr(e, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_Label_is(e));
-    }
-    static Label get() {
-      const ::upb::EnumDef* e = upbdefs_google_protobuf_FieldDescriptorProto_Label_get(&e);
-      return Label(e, &e);
-    }
-  };
-
-  class Type : public ::upb::reffed_ptr<const ::upb::EnumDef> {
-   public:
-    Type(const ::upb::EnumDef* e, const void *ref_donor = NULL)
-        : reffed_ptr(e, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_FieldDescriptorProto_Type_is(e));
-    }
-    static Type get() {
-      const ::upb::EnumDef* e = upbdefs_google_protobuf_FieldDescriptorProto_Type_get(&e);
-      return Type(e, &e);
-    }
-  };
-};
-
-class FieldOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  FieldOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_is(m));
-  }
-
-  static FieldOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_FieldOptions_get(&m);
-    return FieldOptions(m, &m);
-  }
-
-  class CType : public ::upb::reffed_ptr<const ::upb::EnumDef> {
-   public:
-    CType(const ::upb::EnumDef* e, const void *ref_donor = NULL)
-        : reffed_ptr(e, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_CType_is(e));
-    }
-    static CType get() {
-      const ::upb::EnumDef* e = upbdefs_google_protobuf_FieldOptions_CType_get(&e);
-      return CType(e, &e);
-    }
-  };
-
-  class JSType : public ::upb::reffed_ptr<const ::upb::EnumDef> {
-   public:
-    JSType(const ::upb::EnumDef* e, const void *ref_donor = NULL)
-        : reffed_ptr(e, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_FieldOptions_JSType_is(e));
-    }
-    static JSType get() {
-      const ::upb::EnumDef* e = upbdefs_google_protobuf_FieldOptions_JSType_get(&e);
-      return JSType(e, &e);
-    }
-  };
-};
-
-class FileDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  FileDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorProto_is(m));
-  }
-
-  static FileDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_FileDescriptorProto_get(&m);
-    return FileDescriptorProto(m, &m);
-  }
-};
-
-class FileDescriptorSet : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  FileDescriptorSet(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_FileDescriptorSet_is(m));
-  }
-
-  static FileDescriptorSet get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_FileDescriptorSet_get(&m);
-    return FileDescriptorSet(m, &m);
-  }
-};
-
-class FileOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  FileOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_FileOptions_is(m));
-  }
-
-  static FileOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_FileOptions_get(&m);
-    return FileOptions(m, &m);
-  }
-
-  class OptimizeMode : public ::upb::reffed_ptr<const ::upb::EnumDef> {
-   public:
-    OptimizeMode(const ::upb::EnumDef* e, const void *ref_donor = NULL)
-        : reffed_ptr(e, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_FileOptions_OptimizeMode_is(e));
-    }
-    static OptimizeMode get() {
-      const ::upb::EnumDef* e = upbdefs_google_protobuf_FileOptions_OptimizeMode_get(&e);
-      return OptimizeMode(e, &e);
-    }
-  };
-};
-
-class MessageOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  MessageOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_MessageOptions_is(m));
-  }
-
-  static MessageOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_MessageOptions_get(&m);
-    return MessageOptions(m, &m);
-  }
-};
-
-class MethodDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  MethodDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_MethodDescriptorProto_is(m));
-  }
-
-  static MethodDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_MethodDescriptorProto_get(&m);
-    return MethodDescriptorProto(m, &m);
-  }
-};
-
-class MethodOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  MethodOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_MethodOptions_is(m));
-  }
-
-  static MethodOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_MethodOptions_get(&m);
-    return MethodOptions(m, &m);
-  }
-};
-
-class OneofDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  OneofDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_OneofDescriptorProto_is(m));
-  }
-
-  static OneofDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_OneofDescriptorProto_get(&m);
-    return OneofDescriptorProto(m, &m);
-  }
-};
-
-class ServiceDescriptorProto : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  ServiceDescriptorProto(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_ServiceDescriptorProto_is(m));
-  }
-
-  static ServiceDescriptorProto get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_ServiceDescriptorProto_get(&m);
-    return ServiceDescriptorProto(m, &m);
-  }
-};
-
-class ServiceOptions : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  ServiceOptions(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_ServiceOptions_is(m));
-  }
-
-  static ServiceOptions get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_ServiceOptions_get(&m);
-    return ServiceOptions(m, &m);
-  }
-};
-
-class SourceCodeInfo : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  SourceCodeInfo(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_is(m));
-  }
-
-  static SourceCodeInfo get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_SourceCodeInfo_get(&m);
-    return SourceCodeInfo(m, &m);
-  }
-
-  class Location : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    Location(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_SourceCodeInfo_Location_is(m));
-    }
-
-    static Location get() {
-      const ::upb::MessageDef* m = upbdefs_google_protobuf_SourceCodeInfo_Location_get(&m);
-      return Location(m, &m);
-    }
-  };
-};
-
-class UninterpretedOption : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  UninterpretedOption(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_is(m));
-  }
-
-  static UninterpretedOption get() {
-    const ::upb::MessageDef* m = upbdefs_google_protobuf_UninterpretedOption_get(&m);
-    return UninterpretedOption(m, &m);
-  }
-
-  class NamePart : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    NamePart(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_google_protobuf_UninterpretedOption_NamePart_is(m));
-    }
-
-    static NamePart get() {
-      const ::upb::MessageDef* m = upbdefs_google_protobuf_UninterpretedOption_NamePart_get(&m);
-      return NamePart(m, &m);
-    }
-  };
-};
-
-}  /* namespace protobuf */
-}  /* namespace google */
+namespace descriptor {
+inline upb::reffed_ptr<const upb::SymbolTable> SymbolTable() {
+  const upb::SymbolTable* s = upbdefs_google_protobuf_descriptor(&s);
+  return upb::reffed_ptr<const upb::SymbolTable>(s, &s);
+}
+}  /* namespace descriptor */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+#define RETURN_REFFED(type, func) \
+    const type* obj = func(upbdefs::google::protobuf::descriptor::SymbolTable().get()); \
+    return upb::reffed_ptr<const type>(obj);
+
+namespace google {
+namespace protobuf {
+namespace DescriptorProto {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_DescriptorProto) }
+inline upb::reffed_ptr<const upb::FieldDef> enum_type() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_DescriptorProto_enum_type) }
+inline upb::reffed_ptr<const upb::FieldDef> extension() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_DescriptorProto_extension) }
+inline upb::reffed_ptr<const upb::FieldDef> extension_range() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_DescriptorProto_extension_range) }
+inline upb::reffed_ptr<const upb::FieldDef> field() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_DescriptorProto_field) }
+inline upb::reffed_ptr<const upb::FieldDef> name() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_DescriptorProto_name) }
+inline upb::reffed_ptr<const upb::FieldDef> nested_type() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_DescriptorProto_nested_type) }
+inline upb::reffed_ptr<const upb::FieldDef> options() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_DescriptorProto_options) }
+}  /* namespace DescriptorProto */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace DescriptorProto {
+namespace ExtensionRange {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_DescriptorProto_ExtensionRange) }
+inline upb::reffed_ptr<const upb::FieldDef> end() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_DescriptorProto_ExtensionRange_end) }
+inline upb::reffed_ptr<const upb::FieldDef> start() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_DescriptorProto_ExtensionRange_start) }
+}  /* namespace ExtensionRange */
+}  /* namespace DescriptorProto */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace EnumDescriptorProto {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_EnumDescriptorProto) }
+inline upb::reffed_ptr<const upb::FieldDef> name() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_EnumDescriptorProto_name) }
+inline upb::reffed_ptr<const upb::FieldDef> options() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_EnumDescriptorProto_options) }
+inline upb::reffed_ptr<const upb::FieldDef> value() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_EnumDescriptorProto_value) }
+}  /* namespace EnumDescriptorProto */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace EnumOptions {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_EnumOptions) }
+inline upb::reffed_ptr<const upb::FieldDef> allow_alias() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_EnumOptions_allow_alias) }
+inline upb::reffed_ptr<const upb::FieldDef> uninterpreted_option() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_EnumOptions_uninterpreted_option) }
+}  /* namespace EnumOptions */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace EnumValueDescriptorProto {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_EnumValueDescriptorProto) }
+inline upb::reffed_ptr<const upb::FieldDef> name() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_EnumValueDescriptorProto_name) }
+inline upb::reffed_ptr<const upb::FieldDef> number() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_EnumValueDescriptorProto_number) }
+inline upb::reffed_ptr<const upb::FieldDef> options() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_EnumValueDescriptorProto_options) }
+}  /* namespace EnumValueDescriptorProto */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace EnumValueOptions {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_EnumValueOptions) }
+inline upb::reffed_ptr<const upb::FieldDef> uninterpreted_option() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_EnumValueOptions_uninterpreted_option) }
+}  /* namespace EnumValueOptions */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace FieldDescriptorProto {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_FieldDescriptorProto) }
+inline upb::reffed_ptr<const upb::FieldDef> default_value() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldDescriptorProto_default_value) }
+inline upb::reffed_ptr<const upb::FieldDef> extendee() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldDescriptorProto_extendee) }
+inline upb::reffed_ptr<const upb::FieldDef> label() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldDescriptorProto_label) }
+inline upb::reffed_ptr<const upb::FieldDef> name() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldDescriptorProto_name) }
+inline upb::reffed_ptr<const upb::FieldDef> number() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldDescriptorProto_number) }
+inline upb::reffed_ptr<const upb::FieldDef> options() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldDescriptorProto_options) }
+inline upb::reffed_ptr<const upb::FieldDef> type() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldDescriptorProto_type) }
+inline upb::reffed_ptr<const upb::FieldDef> type_name() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldDescriptorProto_type_name) }
+inline upb::reffed_ptr<const upb::EnumDef> Label() { RETURN_REFFED(upb::EnumDef, upbdefs_google_protobuf_FieldDescriptorProto_Label) }
+inline upb::reffed_ptr<const upb::EnumDef> Type() { RETURN_REFFED(upb::EnumDef, upbdefs_google_protobuf_FieldDescriptorProto_Type) }
+}  /* namespace FieldDescriptorProto */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace FieldOptions {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_FieldOptions) }
+inline upb::reffed_ptr<const upb::FieldDef> ctype() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldOptions_ctype) }
+inline upb::reffed_ptr<const upb::FieldDef> deprecated() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldOptions_deprecated) }
+inline upb::reffed_ptr<const upb::FieldDef> experimental_map_key() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldOptions_experimental_map_key) }
+inline upb::reffed_ptr<const upb::FieldDef> lazy() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldOptions_lazy) }
+inline upb::reffed_ptr<const upb::FieldDef> packed() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldOptions_packed) }
+inline upb::reffed_ptr<const upb::FieldDef> uninterpreted_option() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldOptions_uninterpreted_option) }
+inline upb::reffed_ptr<const upb::FieldDef> weak() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FieldOptions_weak) }
+inline upb::reffed_ptr<const upb::EnumDef> CType() { RETURN_REFFED(upb::EnumDef, upbdefs_google_protobuf_FieldOptions_CType) }
+}  /* namespace FieldOptions */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace FileDescriptorProto {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_FileDescriptorProto) }
+inline upb::reffed_ptr<const upb::FieldDef> dependency() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorProto_dependency) }
+inline upb::reffed_ptr<const upb::FieldDef> enum_type() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorProto_enum_type) }
+inline upb::reffed_ptr<const upb::FieldDef> extension() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorProto_extension) }
+inline upb::reffed_ptr<const upb::FieldDef> message_type() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorProto_message_type) }
+inline upb::reffed_ptr<const upb::FieldDef> name() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorProto_name) }
+inline upb::reffed_ptr<const upb::FieldDef> options() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorProto_options) }
+inline upb::reffed_ptr<const upb::FieldDef> package() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorProto_package) }
+inline upb::reffed_ptr<const upb::FieldDef> public_dependency() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorProto_public_dependency) }
+inline upb::reffed_ptr<const upb::FieldDef> service() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorProto_service) }
+inline upb::reffed_ptr<const upb::FieldDef> source_code_info() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorProto_source_code_info) }
+inline upb::reffed_ptr<const upb::FieldDef> weak_dependency() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorProto_weak_dependency) }
+}  /* namespace FileDescriptorProto */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace FileDescriptorSet {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_FileDescriptorSet) }
+inline upb::reffed_ptr<const upb::FieldDef> file() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileDescriptorSet_file) }
+}  /* namespace FileDescriptorSet */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace FileOptions {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_FileOptions) }
+inline upb::reffed_ptr<const upb::FieldDef> cc_generic_services() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileOptions_cc_generic_services) }
+inline upb::reffed_ptr<const upb::FieldDef> go_package() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileOptions_go_package) }
+inline upb::reffed_ptr<const upb::FieldDef> java_generate_equals_and_hash() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileOptions_java_generate_equals_and_hash) }
+inline upb::reffed_ptr<const upb::FieldDef> java_generic_services() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileOptions_java_generic_services) }
+inline upb::reffed_ptr<const upb::FieldDef> java_multiple_files() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileOptions_java_multiple_files) }
+inline upb::reffed_ptr<const upb::FieldDef> java_outer_classname() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileOptions_java_outer_classname) }
+inline upb::reffed_ptr<const upb::FieldDef> java_package() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileOptions_java_package) }
+inline upb::reffed_ptr<const upb::FieldDef> optimize_for() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileOptions_optimize_for) }
+inline upb::reffed_ptr<const upb::FieldDef> py_generic_services() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileOptions_py_generic_services) }
+inline upb::reffed_ptr<const upb::FieldDef> uninterpreted_option() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_FileOptions_uninterpreted_option) }
+inline upb::reffed_ptr<const upb::EnumDef> OptimizeMode() { RETURN_REFFED(upb::EnumDef, upbdefs_google_protobuf_FileOptions_OptimizeMode) }
+}  /* namespace FileOptions */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace MessageOptions {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_MessageOptions) }
+inline upb::reffed_ptr<const upb::FieldDef> message_set_wire_format() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_MessageOptions_message_set_wire_format) }
+inline upb::reffed_ptr<const upb::FieldDef> no_standard_descriptor_accessor() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_MessageOptions_no_standard_descriptor_accessor) }
+inline upb::reffed_ptr<const upb::FieldDef> uninterpreted_option() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_MessageOptions_uninterpreted_option) }
+}  /* namespace MessageOptions */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace MethodDescriptorProto {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_MethodDescriptorProto) }
+inline upb::reffed_ptr<const upb::FieldDef> input_type() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_MethodDescriptorProto_input_type) }
+inline upb::reffed_ptr<const upb::FieldDef> name() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_MethodDescriptorProto_name) }
+inline upb::reffed_ptr<const upb::FieldDef> options() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_MethodDescriptorProto_options) }
+inline upb::reffed_ptr<const upb::FieldDef> output_type() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_MethodDescriptorProto_output_type) }
+}  /* namespace MethodDescriptorProto */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace MethodOptions {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_MethodOptions) }
+inline upb::reffed_ptr<const upb::FieldDef> uninterpreted_option() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_MethodOptions_uninterpreted_option) }
+}  /* namespace MethodOptions */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace ServiceDescriptorProto {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_ServiceDescriptorProto) }
+inline upb::reffed_ptr<const upb::FieldDef> method() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_ServiceDescriptorProto_method) }
+inline upb::reffed_ptr<const upb::FieldDef> name() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_ServiceDescriptorProto_name) }
+inline upb::reffed_ptr<const upb::FieldDef> options() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_ServiceDescriptorProto_options) }
+}  /* namespace ServiceDescriptorProto */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace ServiceOptions {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_ServiceOptions) }
+inline upb::reffed_ptr<const upb::FieldDef> uninterpreted_option() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_ServiceOptions_uninterpreted_option) }
+}  /* namespace ServiceOptions */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace SourceCodeInfo {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_SourceCodeInfo) }
+inline upb::reffed_ptr<const upb::FieldDef> location() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_SourceCodeInfo_location) }
+}  /* namespace SourceCodeInfo */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace SourceCodeInfo {
+namespace Location {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_SourceCodeInfo_Location) }
+inline upb::reffed_ptr<const upb::FieldDef> leading_comments() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_SourceCodeInfo_Location_leading_comments) }
+inline upb::reffed_ptr<const upb::FieldDef> path() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_SourceCodeInfo_Location_path) }
+inline upb::reffed_ptr<const upb::FieldDef> span() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_SourceCodeInfo_Location_span) }
+inline upb::reffed_ptr<const upb::FieldDef> trailing_comments() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_SourceCodeInfo_Location_trailing_comments) }
+}  /* namespace Location */
+}  /* namespace SourceCodeInfo */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace UninterpretedOption {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_UninterpretedOption) }
+inline upb::reffed_ptr<const upb::FieldDef> aggregate_value() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_UninterpretedOption_aggregate_value) }
+inline upb::reffed_ptr<const upb::FieldDef> double_value() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_UninterpretedOption_double_value) }
+inline upb::reffed_ptr<const upb::FieldDef> identifier_value() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_UninterpretedOption_identifier_value) }
+inline upb::reffed_ptr<const upb::FieldDef> name() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_UninterpretedOption_name) }
+inline upb::reffed_ptr<const upb::FieldDef> negative_int_value() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_UninterpretedOption_negative_int_value) }
+inline upb::reffed_ptr<const upb::FieldDef> positive_int_value() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_UninterpretedOption_positive_int_value) }
+inline upb::reffed_ptr<const upb::FieldDef> string_value() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_UninterpretedOption_string_value) }
+}  /* namespace UninterpretedOption */
+}  /* namespace protobuf */
+}  /* namespace google */
+
+namespace google {
+namespace protobuf {
+namespace UninterpretedOption {
+namespace NamePart {
+inline upb::reffed_ptr<const upb::MessageDef> MessageDef() { RETURN_REFFED(upb::MessageDef, upbdefs_google_protobuf_UninterpretedOption_NamePart) }
+inline upb::reffed_ptr<const upb::FieldDef> is_extension() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_UninterpretedOption_NamePart_is_extension) }
+inline upb::reffed_ptr<const upb::FieldDef> name_part() { RETURN_REFFED(upb::FieldDef, upbdefs_google_protobuf_UninterpretedOption_NamePart_name_part) }
+}  /* namespace NamePart */
+}  /* namespace UninterpretedOption */
+}  /* namespace protobuf */
+}  /* namespace google */
+
 }  /* namespace upbdefs */
 
-#endif  /* __cplusplus */
-
-#endif  /* UPB_DESCRIPTOR_DESCRIPTOR_PROTO_UPB_H_ */
+
+#undef RETURN_REFFED
+#endif /* __cplusplus */
+
+#endif  /* GOOGLE_PROTOBUF_DESCRIPTOR_UPB_H_ */
 /*
 ** Internal-only definitions for the decoder.
 */
 
 #ifndef UPB_DECODER_INT_H_
 #define UPB_DECODER_INT_H_
 
+#include <stdlib.h>
 /*
 ** upb::pb::Decoder
 **
 ** A high performance, streaming, resumable decoder for the binary protobuf
 ** format.
 **
 ** This interface works the same regardless of what decoder backend is being
 ** used.  A client of this class does not need to know whether decoding is using
 ** a JITted decoder (DynASM, LLVM, etc) or an interpreted decoder.  By default,
 ** it will always use the fastest available decoder.  However, you can call
@@ skipping 16 matching lines @@
 }  /* namespace upb */
 #endif
 
 UPB_DECLARE_TYPE(upb::pb::CodeCache, upb_pbcodecache)
 UPB_DECLARE_TYPE(upb::pb::Decoder, upb_pbdecoder)
 UPB_DECLARE_TYPE(upb::pb::DecoderMethodOptions, upb_pbdecodermethodopts)
 
 UPB_DECLARE_DERIVED_TYPE(upb::pb::DecoderMethod, upb::RefCounted,
                          upb_pbdecodermethod, upb_refcounted)
 
-/* The maximum number of bytes we are required to buffer internally between
- * calls to the decoder.  The value is 14: a 5 byte unknown tag plus ten-byte
- * varint, less one because we are buffering an incomplete value.
- *
- * Should only be used by unit tests. */
-#define UPB_DECODER_MAX_RESIDUAL_BYTES 14
-
 #ifdef __cplusplus
 
 /* The parameters one uses to construct a DecoderMethod.
  * TODO(haberman): move allowjit here?  Seems more convenient for users.
  * TODO(haberman): move this to be heap allocated for ABI stability. */
 class upb::pb::DecoderMethodOptions {
  public:
   /* Parameter represents the destination handlers that this method will push
    * to. */
   explicit DecoderMethodOptions(const Handlers* dest_handlers);
@@ skipping 36 matching lines @@
  private:
   UPB_DISALLOW_POD_OPS(DecoderMethod, upb::pb::DecoderMethod)
 };
 
 #endif
 
 /* Preallocation hint: decoder won't allocate more bytes than this when first
  * constructed.  This hint may be an overestimate for some build configurations.
  * But if the decoder library is upgraded without recompiling the application,
  * it may be an underestimate. */
-#define UPB_PB_DECODER_SIZE 4416
+#define UPB_PB_DECODER_SIZE 4408
 
 #ifdef __cplusplus
 
 /* A Decoder receives binary protobuf data on its input sink and pushes the
  * decoded data to its output sink. */
 class upb::pb::Decoder {
  public:
   /* Constructs a decoder instance for the given method, which must outlive this
    * decoder.  Any errors during parsing will be set on the given status, which
    * must also outlive this decoder.
@@ skipping 397 matching lines @@
 
   /* End of the delimited region, relative to ptr, NULL if not in this buf. */
   const char *delim_end;
 
   /* End of the delimited region, relative to ptr, end if not in this buf. */
   const char *data_end;
 
   /* Overall stream offset of "buf." */
   uint64_t bufstart_ofs;
 
-  /* Buffer for residual bytes not parsed from the previous buffer. */
-  char residual[UPB_DECODER_MAX_RESIDUAL_BYTES];
+  /* Buffer for residual bytes not parsed from the previous buffer.
+   * The maximum number of residual bytes we require is 12; a five-byte
+   * unknown tag plus an eight-byte value, less one because the value
+   * is only a partial value. */
+  char residual[12];
   char *residual_end;
 
   /* Bytes of data that should be discarded from the input beore we start
    * parsing again.  We set this when we internally determine that we can
    * safely skip the next N bytes, but this region extends past the current
    * user buffer. */
   size_t skip;
 
   /* Stores the user buffer passed to our decode function. */
   const char *buf_param;
@@ skipping 246 matching lines @@
 UPB_INLINE size_t upb_varint_size(uint64_t val) {
   char buf[UPB_PB_VARINT_MAX_LEN];
   return upb_vencode64(val, buf);
 }
 
 /* Encodes a 32-bit varint, *not* sign-extended. */
 UPB_INLINE uint64_t upb_vencode32(uint32_t val) {
   char buf[UPB_PB_VARINT_MAX_LEN];
   size_t bytes = upb_vencode64(val, buf);
   uint64_t ret = 0;
-  UPB_ASSERT(bytes <= 5);
+  assert(bytes <= 5);
   memcpy(&ret, buf, bytes);
-  UPB_ASSERT(ret <= 0xffffffffffU);
+  assert(ret <= 0xffffffffffU);
   return ret;
 }
 
 #ifdef __cplusplus
 }  /* extern "C" */
 #endif
 
 #endif  /* UPB_VARINT_DECODER_H_ */
 /*
 ** upb::pb::Encoder (upb_pb_encoder)
@@ skipping 104 matching lines @@
 ** of data and efficiency is an issue, these may not be the best functions to
 ** use (though they are useful for prototyping, before optimizing).
 */
 
 #ifndef UPB_GLUE_H
 #define UPB_GLUE_H
 
 #include <stdbool.h>
 
 #ifdef __cplusplus
-#include <vector>
-
 extern "C" {
 #endif
 
-/* Loads a binary descriptor and returns a NULL-terminated array of unfrozen
- * filedefs.  The caller owns the returned array, which must be freed with
- * upb_gfree(). */
-upb_filedef **upb_loaddescriptor(const char *buf, size_t n, const void *owner,
-                                 upb_status *status);
+/* Loads all defs from the given protobuf binary descriptor, setting default
+ * accessors and a default layout on all messages.  The caller owns the
+ * returned array of defs, which will be of length *n.  On error NULL is
+ * returned and status is set (if non-NULL). */
+upb_def **upb_load_defs_from_descriptor(const char *str, size_t len, int *n,
+                                        void *owner, upb_status *status);
+
+/* Like the previous but also adds the loaded defs to the given symtab. */
+bool upb_load_descriptor_into_symtab(upb_symtab *symtab, const char *str,
+                                     size_t len, upb_status *status);
+
+/* Like the previous but also reads the descriptor from the given filename. */
+bool upb_load_descriptor_file_into_symtab(upb_symtab *symtab, const char *fname,
+                                          upb_status *status);
+
+/* Reads the given filename into a character string, returning NULL if there
+ * was an error. */
+char *upb_readfile(const char *filename, size_t *len);
 
 #ifdef __cplusplus
 }  /* extern "C" */
 
 namespace upb {
 
-inline bool LoadDescriptor(const char* buf, size_t n, Status* status,
-                           std::vector<reffed_ptr<FileDef> >* files) {
-  FileDef** parsed_files = upb_loaddescriptor(buf, n, &parsed_files, status);
+/* All routines that load descriptors expect the descriptor to be a
+ * FileDescriptorSet. */
+inline bool LoadDescriptorFileIntoSymtab(SymbolTable* s, const char *fname,
+                                         Status* status) {
+  return upb_load_descriptor_file_into_symtab(s, fname, status);
+}
 
-  if (parsed_files) {
-    FileDef** p = parsed_files;
-    while (*p) {
-      files->push_back(reffed_ptr<FileDef>(*p, &parsed_files));
-      ++p;
-    }
-    free(parsed_files);
-    return true;
-  } else {
-    return false;
-  }
+inline bool LoadDescriptorIntoSymtab(SymbolTable* s, const char* str,
+                                     size_t len, Status* status) {
+  return upb_load_descriptor_into_symtab(s, str, len, status);
 }
 
 /* Templated so it can accept both string and std::string. */
 template <typename T>
-bool LoadDescriptor(const T& desc, Status* status,
-                    std::vector<reffed_ptr<FileDef> >* files) {
-  return LoadDescriptor(desc.c_str(), desc.size(), status, files);
+bool LoadDescriptorIntoSymtab(SymbolTable* s, const T& desc, Status* status) {
+  return upb_load_descriptor_into_symtab(s, desc.c_str(), desc.size(), status);
 }
 
 }  /* namespace upb */
 
 #endif
 
 #endif  /* UPB_GLUE_H */
 /*
 ** upb::pb::TextPrinter (upb_textprinter)
 **
@@ skipping 81 matching lines @@
 */
 
 #ifndef UPB_JSON_PARSER_H_
 #define UPB_JSON_PARSER_H_
 
 
 #ifdef __cplusplus
 namespace upb {
 namespace json {
 class Parser;
-class ParserMethod;
 }  /* namespace json */
 }  /* namespace upb */
 #endif
 
 UPB_DECLARE_TYPE(upb::json::Parser, upb_json_parser)
-UPB_DECLARE_DERIVED_TYPE(upb::json::ParserMethod, upb::RefCounted,
-                         upb_json_parsermethod, upb_refcounted)
 
 /* upb::json::Parser **********************************************************/
 
 /* Preallocation hint: parser won't allocate more bytes than this when first
  * constructed.  This hint may be an overestimate for some build configurations.
  * But if the parser library is upgraded without recompiling the application,
  * it may be an underestimate. */
-#define UPB_JSON_PARSER_SIZE 4112
+#define UPB_JSON_PARSER_SIZE 3704
 
 #ifdef __cplusplus
 
 /* Parses an incoming BytesStream, pushing the results to the destination
  * sink. */
 class upb::json::Parser {
  public:
-  static Parser* Create(Environment* env, const ParserMethod* method,
-                        Sink* output);
+  static Parser* Create(Environment* env, Sink* output);
 
   BytesSink* input();
 
  private:
   UPB_DISALLOW_POD_OPS(Parser, upb::json::Parser)
 };
 
-class upb::json::ParserMethod {
- public:
-  /* Include base methods from upb::ReferenceCounted. */
-  UPB_REFCOUNTED_CPPMETHODS
-
-  /* Returns handlers for parsing according to the specified schema. */
-  static reffed_ptr<const ParserMethod> New(const upb::MessageDef* md);
-
-  /* The destination handlers that are statically bound to this method.
-   * This method is only capable of outputting to a sink that uses these
-   * handlers. */
-  const Handlers* dest_handlers() const;
-
-  /* The input handlers for this decoder method. */
-  const BytesHandler* input_handler() const;
-
- private:
-  UPB_DISALLOW_POD_OPS(ParserMethod, upb::json::ParserMethod)
-};
-
 #endif
 
 UPB_BEGIN_EXTERN_C
 
-upb_json_parser* upb_json_parser_create(upb_env* e,
-                                        const upb_json_parsermethod* m,
-                                        upb_sink* output);
+upb_json_parser *upb_json_parser_create(upb_env *e, upb_sink *output);
 upb_bytessink *upb_json_parser_input(upb_json_parser *p);
 
-upb_json_parsermethod* upb_json_parsermethod_new(const upb_msgdef* md,
-                                                 const void* owner);
-const upb_handlers *upb_json_parsermethod_desthandlers(
-    const upb_json_parsermethod *m);
-const upb_byteshandler *upb_json_parsermethod_inputhandler(
-    const upb_json_parsermethod *m);
-
-/* Include refcounted methods like upb_json_parsermethod_ref(). */
-UPB_REFCOUNTED_CMETHODS(upb_json_parsermethod, upb_json_parsermethod_upcast)
-
 UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 
 namespace upb {
 namespace json {
-inline Parser* Parser::Create(Environment* env, const ParserMethod* method,
-                              Sink* output) {
-  return upb_json_parser_create(env, method, output);
+inline Parser* Parser::Create(Environment* env, Sink* output) {
+  return upb_json_parser_create(env, output);
 }
 inline BytesSink* Parser::input() {
   return upb_json_parser_input(this);
 }
-
-inline const Handlers* ParserMethod::dest_handlers() const {
-  return upb_json_parsermethod_desthandlers(this);
-}
-inline const BytesHandler* ParserMethod::input_handler() const {
-  return upb_json_parsermethod_inputhandler(this);
-}
-/* static */
-inline reffed_ptr<const ParserMethod> ParserMethod::New(
-    const MessageDef* md) {
-  const upb_json_parsermethod *m = upb_json_parsermethod_new(md, &m);
-  return reffed_ptr<const ParserMethod>(m, &m);
-}
-
 }  /* namespace json */
 }  /* namespace upb */
 
 #endif
 
 
 #endif  /* UPB_JSON_PARSER_H_ */
 /*
 ** upb::json::Printer
 **
@@ skipping 10 matching lines @@
 class Printer;
 }  /* namespace json */
 }  /* namespace upb */
 #endif
 
 UPB_DECLARE_TYPE(upb::json::Printer, upb_json_printer)
 
 
 /* upb::json::Printer *********************************************************/
 
-#define UPB_JSON_PRINTER_SIZE 176
+#define UPB_JSON_PRINTER_SIZE 168
 
 #ifdef __cplusplus
 
 /* Prints an incoming stream of data to a BytesSink in JSON format. */
 class upb::json::Printer {
  public:
   static Printer* Create(Environment* env, const upb::Handlers* handlers,
                          BytesSink* output);
 
   /* The input to the printer. */
   Sink* input();
 
-  /* Returns handlers for printing according to the specified schema.
-   * If preserve_proto_fieldnames is true, the output JSON will use the
-   * original .proto field names (ie. {"my_field":3}) instead of using
-   * camelCased names, which is the default: (eg. {"myField":3}). */
-  static reffed_ptr<const Handlers> NewHandlers(const upb::MessageDef* md,
-                                                bool preserve_proto_fieldnames);
+  /* Returns handlers for printing according to the specified schema. */
+  static reffed_ptr<const Handlers> NewHandlers(const upb::MessageDef* md);
 
   static const size_t kSize = UPB_JSON_PRINTER_SIZE;
 
  private:
   UPB_DISALLOW_POD_OPS(Printer, upb::json::Printer)
 };
 
 #endif
 
 UPB_BEGIN_EXTERN_C
 
 /* Native C API. */
 upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
                                           upb_bytessink *output);
 upb_sink *upb_json_printer_input(upb_json_printer *p);
 const upb_handlers *upb_json_printer_newhandlers(const upb_msgdef *md,
-                                                 bool preserve_fieldnames,
                                                  const void *owner);
 
 UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 
 namespace upb {
 namespace json {
 inline Printer* Printer::Create(Environment* env, const upb::Handlers* handlers,
                                 BytesSink* output) {
   return upb_json_printer_create(env, handlers, output);
 }
 inline Sink* Printer::input() { return upb_json_printer_input(this); }
 inline reffed_ptr<const Handlers> Printer::NewHandlers(
-    const upb::MessageDef *md, bool preserve_proto_fieldnames) {
-  const Handlers* h = upb_json_printer_newhandlers(
-      md, preserve_proto_fieldnames, &h);
+    const upb::MessageDef *md) {
+  const Handlers* h = upb_json_printer_newhandlers(md, &h);
   return reffed_ptr<const Handlers>(h, &h);
 }
 }  /* namespace json */
 }  /* namespace upb */
 
 #endif
 
 #endif  /* UPB_JSON_TYPED_PRINTER_H_ */