google-protobuf 3.11.4-x64-mingw32 → 3.12.0.rc.1-x64-mingw32

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.


This version of google-protobuf might be problematic. Click here for more details.

@@ -21,9 +21,7 @@
21
21
  *
22
22
  * This file is private and must not be included by users!
23
23
  */
24
- #ifndef UINTPTR_MAX
25
- #error must include stdint.h first
26
- #endif
24
+ #include <stdint.h>
27
25
 
28
26
  #if UINTPTR_MAX == 0xffffffff
29
27
  #define UPB_SIZE(size32, size64) size32
@@ -31,17 +29,21 @@
31
29
  #define UPB_SIZE(size32, size64) size64
32
30
  #endif
33
31
 
34
- #define UPB_FIELD_AT(msg, fieldtype, offset) \
35
- *(fieldtype*)((const char*)(msg) + offset)
32
+ /* If we always read/write as a consistent type to each address, this shouldn't
33
+ * violate aliasing.
34
+ */
35
+ #define UPB_PTR_AT(msg, ofs, type) ((type*)((char*)(msg) + (ofs)))
36
36
 
37
37
  #define UPB_READ_ONEOF(msg, fieldtype, offset, case_offset, case_val, default) \
38
- UPB_FIELD_AT(msg, int, case_offset) == case_val \
39
- ? UPB_FIELD_AT(msg, fieldtype, offset) \
38
+ *UPB_PTR_AT(msg, case_offset, int) == case_val \
39
+ ? *UPB_PTR_AT(msg, offset, fieldtype) \
40
40
  : default
41
41
 
42
42
  #define UPB_WRITE_ONEOF(msg, fieldtype, offset, value, case_offset, case_val) \
43
- UPB_FIELD_AT(msg, int, case_offset) = case_val; \
44
- UPB_FIELD_AT(msg, fieldtype, offset) = value;
43
+ *UPB_PTR_AT(msg, case_offset, int) = case_val; \
44
+ *UPB_PTR_AT(msg, offset, fieldtype) = value;
45
+
46
+ #define UPB_MAPTYPE_STRING 0
45
47
 
46
48
  /* UPB_INLINE: inline if possible, emit standalone code if required. */
47
49
  #ifdef __cplusplus
@@ -115,7 +117,7 @@ int msvc_vsnprintf(char* s, size_t n, const char* format, va_list arg);
115
117
  #ifdef __cplusplus
116
118
  #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) || \
117
119
  (defined(_MSC_VER) && _MSC_VER >= 1900)
118
- // C++11 is present
120
+ /* C++11 is present */
119
121
  #else
120
122
  #error upb requires C++11 for C++ support
121
123
  #endif
@@ -126,6 +128,18 @@ int msvc_vsnprintf(char* s, size_t n, const char* format, va_list arg);
126
128
 
127
129
  #define UPB_UNUSED(var) (void)var
128
130
 
131
+ /* UPB_ASSUME(): in release mode, we tell the compiler to assume this is true.
132
+ */
133
+ #ifdef NDEBUG
134
+ #ifdef __GNUC__
135
+ #define UPB_ASSUME(expr) if (!(expr)) __builtin_unreachable()
136
+ #else
137
+ #define UPB_ASSUME(expr) do {} if (false && (expr))
138
+ #endif
139
+ #else
140
+ #define UPB_ASSUME(expr) assert(expr)
141
+ #endif
142
+
129
143
  /* UPB_ASSERT(): in release mode, we use the expression without letting it be
130
144
  * evaluated. This prevents "unused variable" warnings. */
131
145
  #ifdef NDEBUG
@@ -152,10 +166,51 @@ int msvc_vsnprintf(char* s, size_t n, const char* format, va_list arg);
152
166
  #define UPB_INFINITY (1.0 / 0.0)
153
167
  #endif
154
168
  /*
155
- ** This file contains shared definitions that are widely used across upb.
169
+ ** upb_decode: parsing into a upb_msg using a upb_msglayout.
170
+ */
171
+
172
+ #ifndef UPB_DECODE_H_
173
+ #define UPB_DECODE_H_
174
+
175
+ /*
176
+ ** Our memory representation for parsing tables and messages themselves.
177
+ ** Functions in this file are used by generated code and possibly reflection.
156
178
  **
157
- ** This is a mixed C/C++ interface that offers a full API to both languages.
158
- ** See the top-level README for more information.
179
+ ** The definitions in this file are internal to upb.
180
+ **/
181
+
182
+ #ifndef UPB_MSG_H_
183
+ #define UPB_MSG_H_
184
+
185
+ #include <stdint.h>
186
+ #include <string.h>
187
+
188
+ /*
189
+ ** upb_table
190
+ **
191
+ ** This header is INTERNAL-ONLY! Its interfaces are not public or stable!
192
+ ** This file defines very fast int->upb_value (inttable) and string->upb_value
193
+ ** (strtable) hash tables.
194
+ **
195
+ ** The table uses chained scatter with Brent's variation (inspired by the Lua
196
+ ** implementation of hash tables). The hash function for strings is Austin
197
+ ** Appleby's "MurmurHash."
198
+ **
199
+ ** The inttable uses uintptr_t as its key, which guarantees it can be used to
200
+ ** store pointers or integers of at least 32 bits (upb isn't really useful on
201
+ ** systems where sizeof(void*) < 4).
202
+ **
203
+ ** The table must be homogenous (all values of the same type). In debug
204
+ ** mode, we check this on insert and lookup.
205
+ */
206
+
207
+ #ifndef UPB_TABLE_H_
208
+ #define UPB_TABLE_H_
209
+
210
+ #include <stdint.h>
211
+ #include <string.h>
212
+ /*
213
+ ** This file contains shared definitions that are widely used across upb.
159
214
  */
160
215
 
161
216
  #ifndef UPB_H_
@@ -168,23 +223,13 @@ int msvc_vsnprintf(char* s, size_t n, const char* format, va_list arg);
168
223
  #include <stdint.h>
169
224
  #include <string.h>
170
225
 
226
+
171
227
  #ifdef __cplusplus
172
- #include <memory>
173
- namespace upb {
174
- class Arena;
175
- class Status;
176
- template <int N> class InlinedArena;
177
- }
228
+ extern "C" {
178
229
  #endif
179
230
 
180
-
181
231
  /* upb_status *****************************************************************/
182
232
 
183
- /* upb_status represents a success or failure status and error message.
184
- * It owns no resources and allocates no memory, so it should work
185
- * even in OOM situations. */
186
-
187
- /* The maximum length of an error message before it will get truncated. */
188
233
  #define UPB_STATUS_MAX_MESSAGE 127
189
234
 
190
235
  typedef struct {
@@ -192,59 +237,15 @@ typedef struct {
192
237
  char msg[UPB_STATUS_MAX_MESSAGE]; /* Error message; NULL-terminated. */
193
238
  } upb_status;
194
239
 
195
- #ifdef __cplusplus
196
- extern "C" {
197
- #endif
198
-
199
240
  const char *upb_status_errmsg(const upb_status *status);
200
241
  bool upb_ok(const upb_status *status);
201
242
 
202
- /* Any of the functions that write to a status object allow status to be NULL,
203
- * to support use cases where the function's caller does not care about the
204
- * status message. */
243
+ /* These are no-op if |status| is NULL. */
205
244
  void upb_status_clear(upb_status *status);
206
245
  void upb_status_seterrmsg(upb_status *status, const char *msg);
207
246
  void upb_status_seterrf(upb_status *status, const char *fmt, ...);
208
247
  void upb_status_vseterrf(upb_status *status, const char *fmt, va_list args);
209
248
 
210
- UPB_INLINE void upb_status_setoom(upb_status *status) {
211
- upb_status_seterrmsg(status, "out of memory");
212
- }
213
-
214
- #ifdef __cplusplus
215
- } /* extern "C" */
216
-
217
- class upb::Status {
218
- public:
219
- Status() { upb_status_clear(&status_); }
220
-
221
- upb_status* ptr() { return &status_; }
222
-
223
- /* Returns true if there is no error. */
224
- bool ok() const { return upb_ok(&status_); }
225
-
226
- /* Guaranteed to be NULL-terminated. */
227
- const char *error_message() const { return upb_status_errmsg(&status_); }
228
-
229
- /* The error message will be truncated if it is longer than
230
- * UPB_STATUS_MAX_MESSAGE-4. */
231
- void SetErrorMessage(const char *msg) { upb_status_seterrmsg(&status_, msg); }
232
- void SetFormattedErrorMessage(const char *fmt, ...) {
233
- va_list args;
234
- va_start(args, fmt);
235
- upb_status_vseterrf(&status_, fmt, args);
236
- va_end(args);
237
- }
238
-
239
- /* Resets the status to a successful state with no message. */
240
- void Clear() { upb_status_clear(&status_); }
241
-
242
- private:
243
- upb_status status_;
244
- };
245
-
246
- #endif /* __cplusplus */
247
-
248
249
  /** upb_strview ************************************************************/
249
250
 
250
251
  typedef struct {
@@ -311,16 +312,8 @@ UPB_INLINE void upb_free(upb_alloc *alloc, void *ptr) {
311
312
 
312
313
  /* The global allocator used by upb. Uses the standard malloc()/free(). */
313
314
 
314
- #ifdef __cplusplus
315
- extern "C" {
316
- #endif
317
-
318
315
  extern upb_alloc upb_alloc_global;
319
316
 
320
- #ifdef __cplusplus
321
- } /* extern "C" */
322
- #endif
323
-
324
317
  /* Functions that hard-code the global malloc.
325
318
  *
326
319
  * We still get benefit because we can put custom logic into our global
@@ -357,9 +350,18 @@ typedef void upb_cleanup_func(void *ud);
357
350
  struct upb_arena;
358
351
  typedef struct upb_arena upb_arena;
359
352
 
360
- #ifdef __cplusplus
361
- extern "C" {
362
- #endif
353
+ typedef struct {
354
+ /* We implement the allocator interface.
355
+ * This must be the first member of upb_arena! */
356
+ upb_alloc alloc;
357
+
358
+ char *ptr, *end;
359
+ } _upb_arena_head;
360
+
361
+ UPB_INLINE size_t _upb_arena_alignup(size_t size) {
362
+ const size_t maxalign = 16;
363
+ return ((size + maxalign - 1) / maxalign) * maxalign;
364
+ }
363
365
 
364
366
  /* Creates an arena from the given initial block (if any -- n may be 0).
365
367
  * Additional blocks will be allocated from |alloc|. If |alloc| is NULL, this
@@ -368,82 +370,35 @@ upb_arena *upb_arena_init(void *mem, size_t n, upb_alloc *alloc);
368
370
  void upb_arena_free(upb_arena *a);
369
371
  bool upb_arena_addcleanup(upb_arena *a, void *ud, upb_cleanup_func *func);
370
372
  size_t upb_arena_bytesallocated(const upb_arena *a);
373
+ void *_upb_arena_slowmalloc(upb_arena *a, size_t size);
371
374
 
372
375
  UPB_INLINE upb_alloc *upb_arena_alloc(upb_arena *a) { return (upb_alloc*)a; }
373
376
 
374
- /* Convenience wrappers around upb_alloc functions. */
375
-
376
377
  UPB_INLINE void *upb_arena_malloc(upb_arena *a, size_t size) {
377
- return upb_malloc(upb_arena_alloc(a), size);
378
+ _upb_arena_head *h = (_upb_arena_head*)a;
379
+ size = _upb_arena_alignup(size);
380
+ if (UPB_LIKELY((size_t)(h->end - h->ptr) >= size)) {
381
+ void* ret = h->ptr;
382
+ h->ptr += size;
383
+ return ret;
384
+ } else {
385
+ return _upb_arena_slowmalloc(a, size);
386
+ }
378
387
  }
379
388
 
380
389
  UPB_INLINE void *upb_arena_realloc(upb_arena *a, void *ptr, size_t oldsize,
381
390
  size_t size) {
382
- return upb_realloc(upb_arena_alloc(a), ptr, oldsize, size);
391
+ if (oldsize == 0) {
392
+ return upb_arena_malloc(a, size);
393
+ } else {
394
+ return upb_realloc(upb_arena_alloc(a), ptr, oldsize, size);
395
+ }
383
396
  }
384
397
 
385
398
  UPB_INLINE upb_arena *upb_arena_new(void) {
386
399
  return upb_arena_init(NULL, 0, &upb_alloc_global);
387
400
  }
388
401
 
389
- #ifdef __cplusplus
390
- } /* extern "C" */
391
-
392
- class upb::Arena {
393
- public:
394
- /* A simple arena with no initial memory block and the default allocator. */
395
- Arena() : ptr_(upb_arena_new(), upb_arena_free) {}
396
-
397
- upb_arena* ptr() { return ptr_.get(); }
398
-
399
- /* Allows this arena to be used as a generic allocator.
400
- *
401
- * The arena does not need free() calls so when using Arena as an allocator
402
- * it is safe to skip them. However they are no-ops so there is no harm in
403
- * calling free() either. */
404
- upb_alloc *allocator() { return upb_arena_alloc(ptr_.get()); }
405
-
406
- /* Add a cleanup function to run when the arena is destroyed.
407
- * Returns false on out-of-memory. */
408
- bool AddCleanup(void *ud, upb_cleanup_func* func) {
409
- return upb_arena_addcleanup(ptr_.get(), ud, func);
410
- }
411
-
412
- /* Total number of bytes that have been allocated. It is undefined what
413
- * Realloc() does to &arena_ counter. */
414
- size_t BytesAllocated() const { return upb_arena_bytesallocated(ptr_.get()); }
415
-
416
- private:
417
- std::unique_ptr<upb_arena, decltype(&upb_arena_free)> ptr_;
418
- };
419
-
420
- #endif
421
-
422
- /* upb::InlinedArena **********************************************************/
423
-
424
- /* upb::InlinedArena seeds the arenas with a predefined amount of memory. No
425
- * heap memory will be allocated until the initial block is exceeded.
426
- *
427
- * These types only exist in C++ */
428
-
429
- #ifdef __cplusplus
430
-
431
- template <int N> class upb::InlinedArena : public upb::Arena {
432
- public:
433
- InlinedArena() : ptr_(upb_arena_new(&initial_block_, N, &upb_alloc_global)) {}
434
-
435
- upb_arena* ptr() { return ptr_.get(); }
436
-
437
- private:
438
- InlinedArena(const InlinedArena*) = delete;
439
- InlinedArena& operator=(const InlinedArena*) = delete;
440
-
441
- std::unique_ptr<upb_arena, decltype(&upb_arena_free)> ptr_;
442
- char initial_block_[N];
443
- };
444
-
445
- #endif /* __cplusplus */
446
-
447
402
  /* Constants ******************************************************************/
448
403
 
449
404
  /* Generic function type. */
@@ -463,21 +418,17 @@ typedef enum {
463
418
  * types defined in descriptor.proto, which gives INT32 and SINT32 separate
464
419
  * types (we distinguish the two with the "integer encoding" enum below). */
465
420
  typedef enum {
466
- /* Types stored in 1 byte. */
467
421
  UPB_TYPE_BOOL = 1,
468
- /* Types stored in 4 bytes. */
469
422
  UPB_TYPE_FLOAT = 2,
470
423
  UPB_TYPE_INT32 = 3,
471
424
  UPB_TYPE_UINT32 = 4,
472
425
  UPB_TYPE_ENUM = 5, /* Enum values are int32. */
473
- /* Types stored as pointers (probably 4 or 8 bytes). */
474
- UPB_TYPE_STRING = 6,
475
- UPB_TYPE_BYTES = 7,
476
- UPB_TYPE_MESSAGE = 8,
477
- /* Types stored as 8 bytes. */
478
- UPB_TYPE_DOUBLE = 9,
479
- UPB_TYPE_INT64 = 10,
480
- UPB_TYPE_UINT64 = 11
426
+ UPB_TYPE_MESSAGE = 6,
427
+ UPB_TYPE_DOUBLE = 7,
428
+ UPB_TYPE_INT64 = 8,
429
+ UPB_TYPE_UINT64 = 9,
430
+ UPB_TYPE_STRING = 10,
431
+ UPB_TYPE_BYTES = 11
481
432
  } upb_fieldtype_t;
482
433
 
483
434
  /* The repeated-ness of each field; this matches descriptor.proto. */
@@ -489,6 +440,7 @@ typedef enum {
489
440
 
490
441
  /* Descriptor types, as defined in descriptor.proto. */
491
442
  typedef enum {
443
+ /* Old (long) names. TODO(haberman): remove */
492
444
  UPB_DESCRIPTOR_TYPE_DOUBLE = 1,
493
445
  UPB_DESCRIPTOR_TYPE_FLOAT = 2,
494
446
  UPB_DESCRIPTOR_TYPE_INT64 = 3,
@@ -506,145 +458,36 @@ typedef enum {
506
458
  UPB_DESCRIPTOR_TYPE_SFIXED32 = 15,
507
459
  UPB_DESCRIPTOR_TYPE_SFIXED64 = 16,
508
460
  UPB_DESCRIPTOR_TYPE_SINT32 = 17,
509
- UPB_DESCRIPTOR_TYPE_SINT64 = 18
461
+ UPB_DESCRIPTOR_TYPE_SINT64 = 18,
462
+
463
+ UPB_DTYPE_DOUBLE = 1,
464
+ UPB_DTYPE_FLOAT = 2,
465
+ UPB_DTYPE_INT64 = 3,
466
+ UPB_DTYPE_UINT64 = 4,
467
+ UPB_DTYPE_INT32 = 5,
468
+ UPB_DTYPE_FIXED64 = 6,
469
+ UPB_DTYPE_FIXED32 = 7,
470
+ UPB_DTYPE_BOOL = 8,
471
+ UPB_DTYPE_STRING = 9,
472
+ UPB_DTYPE_GROUP = 10,
473
+ UPB_DTYPE_MESSAGE = 11,
474
+ UPB_DTYPE_BYTES = 12,
475
+ UPB_DTYPE_UINT32 = 13,
476
+ UPB_DTYPE_ENUM = 14,
477
+ UPB_DTYPE_SFIXED32 = 15,
478
+ UPB_DTYPE_SFIXED64 = 16,
479
+ UPB_DTYPE_SINT32 = 17,
480
+ UPB_DTYPE_SINT64 = 18
510
481
  } upb_descriptortype_t;
511
482
 
512
- extern const uint8_t upb_desctype_to_fieldtype[];
513
-
514
-
515
- #endif /* UPB_H_ */
516
- /*
517
- ** upb_decode: parsing into a upb_msg using a upb_msglayout.
518
- */
519
-
520
- #ifndef UPB_DECODE_H_
521
- #define UPB_DECODE_H_
522
-
523
- /*
524
- ** Data structures for message tables, used for parsing and serialization.
525
- ** This are much lighter-weight than full reflection, but they are do not
526
- ** have enough information to convert to text format, JSON, etc.
527
- **
528
- ** The definitions in this file are internal to upb.
529
- **/
530
-
531
- #ifndef UPB_MSG_H_
532
- #define UPB_MSG_H_
533
-
534
- #include <stdint.h>
535
- #include <string.h>
536
-
537
- #ifdef __cplusplus
538
- extern "C" {
539
- #endif
540
-
541
- typedef void upb_msg;
542
-
543
- /** upb_msglayout *************************************************************/
544
-
545
- /* upb_msglayout represents the memory layout of a given upb_msgdef. The
546
- * members are public so generated code can initialize them, but users MUST NOT
547
- * read or write any of its members. */
548
-
549
- typedef struct {
550
- uint32_t number;
551
- uint16_t offset;
552
- int16_t presence; /* If >0, hasbit_index+1. If <0, oneof_index+1. */
553
- uint16_t submsg_index; /* undefined if descriptortype != MESSAGE or GROUP. */
554
- uint8_t descriptortype;
555
- uint8_t label;
556
- } upb_msglayout_field;
557
-
558
- typedef struct upb_msglayout {
559
- const struct upb_msglayout *const* submsgs;
560
- const upb_msglayout_field *fields;
561
- /* Must be aligned to sizeof(void*). Doesn't include internal members like
562
- * unknown fields, extension dict, pointer to msglayout, etc. */
563
- uint16_t size;
564
- uint16_t field_count;
565
- bool extendable;
566
- } upb_msglayout;
567
-
568
- /** Message internal representation *******************************************/
569
-
570
- /* Our internal representation for repeated fields. */
571
- typedef struct {
572
- void *data; /* Each element is element_size. */
573
- size_t len; /* Measured in elements. */
574
- size_t size; /* Measured in elements. */
575
- } upb_array;
576
-
577
- upb_msg *upb_msg_new(const upb_msglayout *l, upb_arena *a);
578
- upb_msg *upb_msg_new(const upb_msglayout *l, upb_arena *a);
483
+ #define UPB_MAP_BEGIN -1
579
484
 
580
- void upb_msg_addunknown(upb_msg *msg, const char *data, size_t len,
581
- upb_arena *arena);
582
- const char *upb_msg_getunknown(const upb_msg *msg, size_t *len);
583
-
584
- upb_array *upb_array_new(upb_arena *a);
585
-
586
- #ifdef __cplusplus
587
- } /* extern "C" */
588
- #endif
589
-
590
- #endif /* UPB_MSG_H_ */
591
-
592
- #ifdef __cplusplus
593
- extern "C" {
594
- #endif
595
-
596
- bool upb_decode(const char *buf, size_t size, upb_msg *msg,
597
- const upb_msglayout *l, upb_arena *arena);
598
-
599
- #ifdef __cplusplus
600
- } /* extern "C" */
601
- #endif
602
-
603
- #endif /* UPB_DECODE_H_ */
604
- /*
605
- ** upb_encode: parsing into a upb_msg using a upb_msglayout.
606
- */
607
-
608
- #ifndef UPB_ENCODE_H_
609
- #define UPB_ENCODE_H_
610
-
611
-
612
- #ifdef __cplusplus
613
- extern "C" {
614
- #endif
615
-
616
- char *upb_encode(const void *msg, const upb_msglayout *l, upb_arena *arena,
617
- size_t *size);
618
485
 
619
486
  #ifdef __cplusplus
620
487
  } /* extern "C" */
621
488
  #endif
622
489
 
623
- #endif /* UPB_ENCODE_H_ */
624
- /*
625
- ** upb_table
626
- **
627
- ** This header is INTERNAL-ONLY! Its interfaces are not public or stable!
628
- ** This file defines very fast int->upb_value (inttable) and string->upb_value
629
- ** (strtable) hash tables.
630
- **
631
- ** The table uses chained scatter with Brent's variation (inspired by the Lua
632
- ** implementation of hash tables). The hash function for strings is Austin
633
- ** Appleby's "MurmurHash."
634
- **
635
- ** The inttable uses uintptr_t as its key, which guarantees it can be used to
636
- ** store pointers or integers of at least 32 bits (upb isn't really useful on
637
- ** systems where sizeof(void*) < 4).
638
- **
639
- ** The table must be homogenous (all values of the same type). In debug
640
- ** mode, we check this on insert and lookup.
641
- */
642
-
643
- #ifndef UPB_TABLE_H_
644
- #define UPB_TABLE_H_
645
-
646
- #include <stdint.h>
647
- #include <string.h>
490
+ #endif /* UPB_H_ */
648
491
 
649
492
 
650
493
  #ifdef __cplusplus
@@ -673,19 +516,8 @@ typedef enum {
673
516
 
674
517
  typedef struct {
675
518
  uint64_t val;
676
- #ifndef NDEBUG
677
- /* In debug mode we carry the value type around also so we can check accesses
678
- * to be sure the right member is being read. */
679
- upb_ctype_t ctype;
680
- #endif
681
519
  } upb_value;
682
520
 
683
- #ifdef NDEBUG
684
- #define SET_TYPE(dest, val) UPB_UNUSED(val)
685
- #else
686
- #define SET_TYPE(dest, val) dest = val
687
- #endif
688
-
689
521
  /* Like strdup(), which isn't always available since it's not ANSI C. */
690
522
  char *upb_strdup(const char *s, upb_alloc *a);
691
523
  /* Variant that works with a length-delimited rather than NULL-delimited string,
@@ -696,15 +528,13 @@ UPB_INLINE char *upb_gstrdup(const char *s) {
696
528
  return upb_strdup(s, &upb_alloc_global);
697
529
  }
698
530
 
699
- UPB_INLINE void _upb_value_setval(upb_value *v, uint64_t val,
700
- upb_ctype_t ctype) {
531
+ UPB_INLINE void _upb_value_setval(upb_value *v, uint64_t val) {
701
532
  v->val = val;
702
- SET_TYPE(v->ctype, ctype);
703
533
  }
704
534
 
705
- UPB_INLINE upb_value _upb_value_val(uint64_t val, upb_ctype_t ctype) {
535
+ UPB_INLINE upb_value _upb_value_val(uint64_t val) {
706
536
  upb_value ret;
707
- _upb_value_setval(&ret, val, ctype);
537
+ _upb_value_setval(&ret, val);
708
538
  return ret;
709
539
  }
710
540
 
@@ -719,7 +549,6 @@ UPB_INLINE upb_value _upb_value_val(uint64_t val, upb_ctype_t ctype) {
719
549
  #define FUNCS(name, membername, type_t, converter, proto_type) \
720
550
  UPB_INLINE void upb_value_set ## name(upb_value *val, type_t cval) { \
721
551
  val->val = (converter)cval; \
722
- SET_TYPE(val->ctype, proto_type); \
723
552
  } \
724
553
  UPB_INLINE upb_value upb_value_ ## name(type_t val) { \
725
554
  upb_value ret; \
@@ -727,7 +556,6 @@ UPB_INLINE upb_value _upb_value_val(uint64_t val, upb_ctype_t ctype) {
727
556
  return ret; \
728
557
  } \
729
558
  UPB_INLINE type_t upb_value_get ## name(upb_value val) { \
730
- UPB_ASSERT_DEBUGVAR(val.ctype == proto_type); \
731
559
  return (type_t)(converter)val.val; \
732
560
  }
733
561
 
@@ -745,12 +573,10 @@ FUNCS(fptr, fptr, upb_func*, uintptr_t, UPB_CTYPE_FPTR)
745
573
 
746
574
  UPB_INLINE void upb_value_setfloat(upb_value *val, float cval) {
747
575
  memcpy(&val->val, &cval, sizeof(cval));
748
- SET_TYPE(val->ctype, UPB_CTYPE_FLOAT);
749
576
  }
750
577
 
751
578
  UPB_INLINE void upb_value_setdouble(upb_value *val, double cval) {
752
579
  memcpy(&val->val, &cval, sizeof(cval));
753
- SET_TYPE(val->ctype, UPB_CTYPE_DOUBLE);
754
580
  }
755
581
 
756
582
  UPB_INLINE upb_value upb_value_float(float cval) {
@@ -794,7 +620,6 @@ typedef struct {
794
620
 
795
621
  #define UPB_TABVALUE_EMPTY_INIT {-1}
796
622
 
797
-
798
623
  /* upb_table ******************************************************************/
799
624
 
800
625
  typedef struct _upb_tabent {
@@ -811,7 +636,6 @@ typedef struct _upb_tabent {
811
636
  typedef struct {
812
637
  size_t count; /* Number of entries in the hash part. */
813
638
  size_t mask; /* Mask to turn hash value -> bucket. */
814
- upb_ctype_t ctype; /* Type of all values. */
815
639
  uint8_t size_lg2; /* Size of the hashtable part is 2^size_lg2 entries. */
816
640
 
817
641
  /* Hash table entries.
@@ -821,17 +645,6 @@ typedef struct {
821
645
  * initialize const hash tables. Then we cast away const when we have to.
822
646
  */
823
647
  const upb_tabent *entries;
824
-
825
- #ifndef NDEBUG
826
- /* This table's allocator. We make the user pass it in to every relevant
827
- * function and only use this to check it in debug mode. We do this solely
828
- * to keep upb_table as small as possible. This might seem slightly paranoid
829
- * but the plan is to use upb_table for all map fields and extension sets in
830
- * a forthcoming message representation, so there could be a lot of these.
831
- * If this turns out to be too annoying later, we can change it (since this
832
- * is an internal-only header file). */
833
- upb_alloc *alloc;
834
- #endif
835
648
  } upb_table;
836
649
 
837
650
  typedef struct {
@@ -845,12 +658,6 @@ typedef struct {
845
658
  size_t array_count; /* Array part number of elements. */
846
659
  } upb_inttable;
847
660
 
848
- #define UPB_INTTABLE_INIT(count, mask, ctype, size_lg2, ent, a, asize, acount) \
849
- {UPB_TABLE_INIT(count, mask, ctype, size_lg2, ent), a, asize, acount}
850
-
851
- #define UPB_EMPTY_INTTABLE_INIT(ctype) \
852
- UPB_INTTABLE_INIT(0, 0, ctype, 0, NULL, NULL, 0, 0)
853
-
854
661
  #define UPB_ARRAY_EMPTYENT -1
855
662
 
856
663
  UPB_INLINE size_t upb_table_size(const upb_table *t) {
@@ -919,6 +726,7 @@ upb_inttable *upb_inttable_pack(const upb_inttable *t, void *p, size_t *ofs,
919
726
  size_t size);
920
727
  upb_strtable *upb_strtable_pack(const upb_strtable *t, void *p, size_t *ofs,
921
728
  size_t size);
729
+ void upb_strtable_clear(upb_strtable *t);
922
730
 
923
731
  /* Inserts the given key into the hashtable with the given value. The key must
924
732
  * not already exist in the hash table. For string tables, the key must be
@@ -1020,7 +828,7 @@ UPB_INLINE bool upb_inttable_lookup32(const upb_inttable *t, uint32_t key,
1020
828
  if (key < t->array_size) {
1021
829
  upb_tabval arrval = t->array[key];
1022
830
  if (upb_arrhas(arrval)) {
1023
- _upb_value_setval(v, arrval.val, t->t.ctype);
831
+ _upb_value_setval(v, arrval.val);
1024
832
  return true;
1025
833
  } else {
1026
834
  return false;
@@ -1030,7 +838,7 @@ UPB_INLINE bool upb_inttable_lookup32(const upb_inttable *t, uint32_t key,
1030
838
  if (t->t.entries == NULL) return false;
1031
839
  for (e = upb_getentry(&t->t, upb_inthash(key)); true; e = e->next) {
1032
840
  if ((uint32_t)e->key == key) {
1033
- _upb_value_setval(v, e->val.val, t->t.ctype);
841
+ _upb_value_setval(v, e->val.val);
1034
842
  return true;
1035
843
  }
1036
844
  if (e->next == NULL) return false;
@@ -1084,8 +892,7 @@ typedef struct {
1084
892
  void upb_strtable_begin(upb_strtable_iter *i, const upb_strtable *t);
1085
893
  void upb_strtable_next(upb_strtable_iter *i);
1086
894
  bool upb_strtable_done(const upb_strtable_iter *i);
1087
- const char *upb_strtable_iter_key(const upb_strtable_iter *i);
1088
- size_t upb_strtable_iter_keylength(const upb_strtable_iter *i);
895
+ upb_strview upb_strtable_iter_key(const upb_strtable_iter *i);
1089
896
  upb_value upb_strtable_iter_value(const upb_strtable_iter *i);
1090
897
  void upb_strtable_iter_setdone(upb_strtable_iter *i);
1091
898
  bool upb_strtable_iter_isequal(const upb_strtable_iter *i1,
@@ -1109,6 +916,10 @@ typedef struct {
1109
916
  bool array_part;
1110
917
  } upb_inttable_iter;
1111
918
 
919
+ UPB_INLINE const upb_tabent *str_tabent(const upb_strtable_iter *i) {
920
+ return &i->t->t.entries[i->index];
921
+ }
922
+
1112
923
  void upb_inttable_begin(upb_inttable_iter *i, const upb_inttable *t);
1113
924
  void upb_inttable_next(upb_inttable_iter *i);
1114
925
  bool upb_inttable_done(const upb_inttable_iter *i);
@@ -1125,36 +936,140 @@ bool upb_inttable_iter_isequal(const upb_inttable_iter *i1,
1125
936
 
1126
937
 
1127
938
  #endif /* UPB_TABLE_H_ */
1128
- /* This file was generated by upbc (the upb compiler) from the input
1129
- * file:
1130
- *
1131
- * google/protobuf/descriptor.proto
1132
- *
1133
- * Do not edit -- your changes will be discarded when the file is
1134
- * regenerated. */
1135
939
 
1136
- #ifndef GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H_
1137
- #define GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H_
1138
940
 
1139
- /*
1140
- ** Functions for use by generated code. These are not public and users must
1141
- ** not call them directly.
1142
- */
941
+ #ifdef __cplusplus
942
+ extern "C" {
943
+ #endif
1143
944
 
1144
- #ifndef UPB_GENERATED_UTIL_H_
1145
- #define UPB_GENERATED_UTIL_H_
945
+ #define PTR_AT(msg, ofs, type) (type*)((const char*)msg + ofs)
1146
946
 
1147
- #include <stdint.h>
947
+ typedef void upb_msg;
1148
948
 
949
+ /** upb_msglayout *************************************************************/
1149
950
 
1150
- #define PTR_AT(msg, ofs, type) (type*)((const char*)msg + ofs)
951
+ /* upb_msglayout represents the memory layout of a given upb_msgdef. The
952
+ * members are public so generated code can initialize them, but users MUST NOT
953
+ * read or write any of its members. */
954
+
955
+ /* These aren't real labels according to descriptor.proto, but in the table we
956
+ * use these for map/packed fields instead of UPB_LABEL_REPEATED. */
957
+ enum {
958
+ _UPB_LABEL_MAP = 4,
959
+ _UPB_LABEL_PACKED = 7 /* Low 3 bits are common with UPB_LABEL_REPEATED. */
960
+ };
961
+
962
+ typedef struct {
963
+ uint32_t number;
964
+ uint16_t offset;
965
+ int16_t presence; /* If >0, hasbit_index. If <0, -oneof_index. */
966
+ uint16_t submsg_index; /* undefined if descriptortype != MESSAGE or GROUP. */
967
+ uint8_t descriptortype;
968
+ uint8_t label;
969
+ } upb_msglayout_field;
970
+
971
+ typedef struct upb_msglayout {
972
+ const struct upb_msglayout *const* submsgs;
973
+ const upb_msglayout_field *fields;
974
+ /* Must be aligned to sizeof(void*). Doesn't include internal members like
975
+ * unknown fields, extension dict, pointer to msglayout, etc. */
976
+ uint16_t size;
977
+ uint16_t field_count;
978
+ bool extendable;
979
+ } upb_msglayout;
980
+
981
+ /** upb_msg *******************************************************************/
982
+
983
+ /* Internal members of a upb_msg. We can change this without breaking binary
984
+ * compatibility. We put these before the user's data. The user's upb_msg*
985
+ * points after the upb_msg_internal. */
986
+
987
+ /* Used when a message is not extendable. */
988
+ typedef struct {
989
+ char *unknown;
990
+ size_t unknown_len;
991
+ size_t unknown_size;
992
+ } upb_msg_internal;
993
+
994
+ /* Used when a message is extendable. */
995
+ typedef struct {
996
+ upb_inttable *extdict;
997
+ upb_msg_internal base;
998
+ } upb_msg_internal_withext;
999
+
1000
+ /* Maps upb_fieldtype_t -> memory size. */
1001
+ extern char _upb_fieldtype_to_size[12];
1002
+
1003
+ /* Creates a new messages with the given layout on the given arena. */
1004
+ upb_msg *_upb_msg_new(const upb_msglayout *l, upb_arena *a);
1005
+
1006
+ /* Adds unknown data (serialized protobuf data) to the given message. The data
1007
+ * is copied into the message instance. */
1008
+ bool _upb_msg_addunknown(upb_msg *msg, const char *data, size_t len,
1009
+ upb_arena *arena);
1010
+
1011
+ /* Returns a reference to the message's unknown data. */
1012
+ const char *upb_msg_getunknown(const upb_msg *msg, size_t *len);
1013
+
1014
+ UPB_INLINE bool _upb_has_field(const void *msg, size_t idx) {
1015
+ return (*PTR_AT(msg, idx / 8, const char) & (1 << (idx % 8))) != 0;
1016
+ }
1017
+
1018
+ UPB_INLINE bool _upb_sethas(const void *msg, size_t idx) {
1019
+ return (*PTR_AT(msg, idx / 8, char)) |= (char)(1 << (idx % 8));
1020
+ }
1021
+
1022
+ UPB_INLINE bool _upb_clearhas(const void *msg, size_t idx) {
1023
+ return (*PTR_AT(msg, idx / 8, char)) &= (char)(~(1 << (idx % 8)));
1024
+ }
1025
+
1026
+ UPB_INLINE bool _upb_has_oneof_field(const void *msg, size_t case_ofs, int32_t num) {
1027
+ return *PTR_AT(msg, case_ofs, int32_t) == num;
1028
+ }
1029
+
1030
+ UPB_INLINE bool _upb_has_submsg_nohasbit(const void *msg, size_t ofs) {
1031
+ return *PTR_AT(msg, ofs, const void*) != NULL;
1032
+ }
1033
+
1034
+ UPB_INLINE bool _upb_isrepeated(const upb_msglayout_field *field) {
1035
+ return (field->label & 3) == UPB_LABEL_REPEATED;
1036
+ }
1037
+
1038
+ /** upb_array *****************************************************************/
1039
+
1040
+ /* Our internal representation for repeated fields. */
1041
+ typedef struct {
1042
+ uintptr_t data; /* Tagged ptr: low 3 bits of ptr are lg2(elem size). */
1043
+ size_t len; /* Measured in elements. */
1044
+ size_t size; /* Measured in elements. */
1045
+ } upb_array;
1046
+
1047
+ UPB_INLINE const void *_upb_array_constptr(const upb_array *arr) {
1048
+ return (void*)(arr->data & ~(uintptr_t)7);
1049
+ }
1050
+
1051
+ UPB_INLINE void *_upb_array_ptr(upb_array *arr) {
1052
+ return (void*)_upb_array_constptr(arr);
1053
+ }
1054
+
1055
+ /* Creates a new array on the given arena. */
1056
+ upb_array *_upb_array_new(upb_arena *a, upb_fieldtype_t type);
1057
+
1058
+ /* Resizes the capacity of the array to be at least min_size. */
1059
+ bool _upb_array_realloc(upb_array *arr, size_t min_size, upb_arena *arena);
1060
+
1061
+ /* Fallback functions for when the accessors require a resize. */
1062
+ void *_upb_array_resize_fallback(upb_array **arr_ptr, size_t size,
1063
+ upb_fieldtype_t type, upb_arena *arena);
1064
+ bool _upb_array_append_fallback(upb_array **arr_ptr, const void *value,
1065
+ upb_fieldtype_t type, upb_arena *arena);
1151
1066
 
1152
1067
  UPB_INLINE const void *_upb_array_accessor(const void *msg, size_t ofs,
1153
1068
  size_t *size) {
1154
1069
  const upb_array *arr = *PTR_AT(msg, ofs, const upb_array*);
1155
1070
  if (arr) {
1156
1071
  if (size) *size = arr->len;
1157
- return arr->data;
1072
+ return _upb_array_constptr(arr);
1158
1073
  } else {
1159
1074
  if (size) *size = 0;
1160
1075
  return NULL;
@@ -1166,78 +1081,295 @@ UPB_INLINE void *_upb_array_mutable_accessor(void *msg, size_t ofs,
1166
1081
  upb_array *arr = *PTR_AT(msg, ofs, upb_array*);
1167
1082
  if (arr) {
1168
1083
  if (size) *size = arr->len;
1169
- return arr->data;
1084
+ return _upb_array_ptr(arr);
1170
1085
  } else {
1171
1086
  if (size) *size = 0;
1172
1087
  return NULL;
1173
1088
  }
1174
1089
  }
1175
1090
 
1176
- /* TODO(haberman): this is a mess. It will improve when upb_array no longer
1177
- * carries reflective state (type, elem_size). */
1178
1091
  UPB_INLINE void *_upb_array_resize_accessor(void *msg, size_t ofs, size_t size,
1179
- size_t elem_size,
1180
1092
  upb_fieldtype_t type,
1181
1093
  upb_arena *arena) {
1182
- upb_array *arr = *PTR_AT(msg, ofs, upb_array*);
1183
-
1184
- if (!arr) {
1185
- arr = upb_array_new(arena);
1186
- if (!arr) return NULL;
1187
- *PTR_AT(msg, ofs, upb_array*) = arr;
1188
- }
1189
-
1190
- if (size > arr->size) {
1191
- size_t new_size = UPB_MAX(arr->size, 4);
1192
- size_t old_bytes = arr->size * elem_size;
1193
- size_t new_bytes;
1194
- while (new_size < size) new_size *= 2;
1195
- new_bytes = new_size * elem_size;
1196
- arr->data = upb_arena_realloc(arena, arr->data, old_bytes, new_bytes);
1197
- if (!arr->data) {
1198
- return NULL;
1199
- }
1200
- arr->size = new_size;
1094
+ upb_array **arr_ptr = PTR_AT(msg, ofs, upb_array*);
1095
+ upb_array *arr = *arr_ptr;
1096
+ if (!arr || arr->size < size) {
1097
+ return _upb_array_resize_fallback(arr_ptr, size, type, arena);
1201
1098
  }
1202
-
1203
1099
  arr->len = size;
1204
- return arr->data;
1100
+ return _upb_array_ptr(arr);
1205
1101
  }
1206
1102
 
1103
+
1207
1104
  UPB_INLINE bool _upb_array_append_accessor(void *msg, size_t ofs,
1208
1105
  size_t elem_size,
1209
1106
  upb_fieldtype_t type,
1210
1107
  const void *value,
1211
1108
  upb_arena *arena) {
1212
- upb_array *arr = *PTR_AT(msg, ofs, upb_array*);
1213
- size_t i = arr ? arr->len : 0;
1214
- void *data =
1215
- _upb_array_resize_accessor(msg, ofs, i + 1, elem_size, type, arena);
1216
- if (!data) return false;
1217
- memcpy(PTR_AT(data, i * elem_size, char), value, elem_size);
1109
+ upb_array **arr_ptr = PTR_AT(msg, ofs, upb_array*);
1110
+ upb_array *arr = *arr_ptr;
1111
+ void* ptr;
1112
+ if (!arr || arr->len == arr->size) {
1113
+ return _upb_array_append_fallback(arr_ptr, value, type, arena);
1114
+ }
1115
+ ptr = _upb_array_ptr(arr);
1116
+ memcpy(PTR_AT(ptr, arr->len * elem_size, char), value, elem_size);
1117
+ arr->len++;
1218
1118
  return true;
1219
1119
  }
1220
1120
 
1221
- UPB_INLINE bool _upb_has_field(const void *msg, size_t idx) {
1222
- return (*PTR_AT(msg, idx / 8, const char) & (1 << (idx % 8))) != 0;
1121
+ /** upb_map *******************************************************************/
1122
+
1123
+ /* Right now we use strmaps for everything. We'll likely want to use
1124
+ * integer-specific maps for integer-keyed maps.*/
1125
+ typedef struct {
1126
+ /* Size of key and val, based on the map type. Strings are represented as '0'
1127
+ * because they must be handled specially. */
1128
+ char key_size;
1129
+ char val_size;
1130
+
1131
+ upb_strtable table;
1132
+ } upb_map;
1133
+
1134
+ /* Map entries aren't actually stored, they are only used during parsing. For
1135
+ * parsing, it helps a lot if all map entry messages have the same layout.
1136
+ * The compiler and def.c must ensure that all map entries have this layout. */
1137
+ typedef struct {
1138
+ upb_msg_internal internal;
1139
+ union {
1140
+ upb_strview str; /* For str/bytes. */
1141
+ upb_value val; /* For all other types. */
1142
+ } k;
1143
+ union {
1144
+ upb_strview str; /* For str/bytes. */
1145
+ upb_value val; /* For all other types. */
1146
+ } v;
1147
+ } upb_map_entry;
1148
+
1149
+ /* Creates a new map on the given arena with this key/value type. */
1150
+ upb_map *_upb_map_new(upb_arena *a, size_t key_size, size_t value_size);
1151
+
1152
+ /* Converting between internal table representation and user values.
1153
+ *
1154
+ * _upb_map_tokey() and _upb_map_fromkey() are inverses.
1155
+ * _upb_map_tovalue() and _upb_map_fromvalue() are inverses.
1156
+ *
1157
+ * These functions account for the fact that strings are treated differently
1158
+ * from other types when stored in a map.
1159
+ */
1160
+
1161
+ UPB_INLINE upb_strview _upb_map_tokey(const void *key, size_t size) {
1162
+ if (size == UPB_MAPTYPE_STRING) {
1163
+ return *(upb_strview*)key;
1164
+ } else {
1165
+ return upb_strview_make((const char*)key, size);
1166
+ }
1223
1167
  }
1224
1168
 
1225
- UPB_INLINE bool _upb_sethas(const void *msg, size_t idx) {
1226
- return (*PTR_AT(msg, idx / 8, char)) |= (char)(1 << (idx % 8));
1169
+ UPB_INLINE void _upb_map_fromkey(upb_strview key, void* out, size_t size) {
1170
+ if (size == UPB_MAPTYPE_STRING) {
1171
+ memcpy(out, &key, sizeof(key));
1172
+ } else {
1173
+ memcpy(out, key.data, size);
1174
+ }
1227
1175
  }
1228
1176
 
1229
- UPB_INLINE bool _upb_clearhas(const void *msg, size_t idx) {
1230
- return (*PTR_AT(msg, idx / 8, char)) &= (char)(~(1 << (idx % 8)));
1177
+ UPB_INLINE upb_value _upb_map_tovalue(const void *val, size_t size,
1178
+ upb_arena *a) {
1179
+ upb_value ret = {0};
1180
+ if (size == UPB_MAPTYPE_STRING) {
1181
+ upb_strview *strp = (upb_strview*)upb_arena_malloc(a, sizeof(*strp));
1182
+ *strp = *(upb_strview*)val;
1183
+ memcpy(&ret, &strp, sizeof(strp));
1184
+ } else {
1185
+ memcpy(&ret, val, size);
1186
+ }
1187
+ return ret;
1231
1188
  }
1232
1189
 
1233
- UPB_INLINE bool _upb_has_oneof_field(const void *msg, size_t case_ofs, int32_t num) {
1234
- return *PTR_AT(msg, case_ofs, int32_t) == num;
1190
+ UPB_INLINE void _upb_map_fromvalue(upb_value val, void* out, size_t size) {
1191
+ if (size == UPB_MAPTYPE_STRING) {
1192
+ const upb_strview *strp = (const upb_strview*)upb_value_getptr(val);
1193
+ memcpy(out, strp, sizeof(upb_strview));
1194
+ } else {
1195
+ memcpy(out, &val, size);
1196
+ }
1197
+ }
1198
+
1199
+ /* Map operations, shared by reflection and generated code. */
1200
+
1201
+ UPB_INLINE size_t _upb_map_size(const upb_map *map) {
1202
+ return map->table.t.count;
1203
+ }
1204
+
1205
+ UPB_INLINE bool _upb_map_get(const upb_map *map, const void *key,
1206
+ size_t key_size, void *val, size_t val_size) {
1207
+ upb_value tabval;
1208
+ upb_strview k = _upb_map_tokey(key, key_size);
1209
+ bool ret = upb_strtable_lookup2(&map->table, k.data, k.size, &tabval);
1210
+ if (ret) {
1211
+ _upb_map_fromvalue(tabval, val, val_size);
1212
+ }
1213
+ return ret;
1214
+ }
1215
+
1216
+ UPB_INLINE void* _upb_map_next(const upb_map *map, size_t *iter) {
1217
+ upb_strtable_iter it;
1218
+ it.t = &map->table;
1219
+ it.index = *iter;
1220
+ upb_strtable_next(&it);
1221
+ if (upb_strtable_done(&it)) return NULL;
1222
+ *iter = it.index;
1223
+ return (void*)str_tabent(&it);
1224
+ }
1225
+
1226
+ UPB_INLINE bool _upb_map_set(upb_map *map, const void *key, size_t key_size,
1227
+ void *val, size_t val_size, upb_arena *arena) {
1228
+ upb_strview strkey = _upb_map_tokey(key, key_size);
1229
+ upb_value tabval = _upb_map_tovalue(val, val_size, arena);
1230
+ upb_alloc *a = upb_arena_alloc(arena);
1231
+
1232
+ /* TODO(haberman): add overwrite operation to minimize number of lookups. */
1233
+ upb_strtable_remove3(&map->table, strkey.data, strkey.size, NULL, a);
1234
+ return upb_strtable_insert3(&map->table, strkey.data, strkey.size, tabval, a);
1235
+ }
1236
+
1237
+ UPB_INLINE bool _upb_map_delete(upb_map *map, const void *key, size_t key_size) {
1238
+ upb_strview k = _upb_map_tokey(key, key_size);
1239
+ return upb_strtable_remove3(&map->table, k.data, k.size, NULL, NULL);
1240
+ }
1241
+
1242
+ UPB_INLINE void _upb_map_clear(upb_map *map) {
1243
+ upb_strtable_clear(&map->table);
1244
+ }
1245
+
1246
+ /* Message map operations, these get the map from the message first. */
1247
+
1248
+ UPB_INLINE size_t _upb_msg_map_size(const upb_msg *msg, size_t ofs) {
1249
+ upb_map *map = *UPB_PTR_AT(msg, ofs, upb_map *);
1250
+ return map ? _upb_map_size(map) : 0;
1251
+ }
1252
+
1253
+ UPB_INLINE bool _upb_msg_map_get(const upb_msg *msg, size_t ofs,
1254
+ const void *key, size_t key_size, void *val,
1255
+ size_t val_size) {
1256
+ upb_map *map = *UPB_PTR_AT(msg, ofs, upb_map *);
1257
+ if (!map) return false;
1258
+ return _upb_map_get(map, key, key_size, val, val_size);
1259
+ }
1260
+
1261
+ UPB_INLINE void *_upb_msg_map_next(const upb_msg *msg, size_t ofs,
1262
+ size_t *iter) {
1263
+ upb_map *map = *UPB_PTR_AT(msg, ofs, upb_map *);
1264
+ if (!map) return NULL;
1265
+ return _upb_map_next(map, iter);
1266
+ }
1267
+
1268
+ UPB_INLINE bool _upb_msg_map_set(upb_msg *msg, size_t ofs, const void *key,
1269
+ size_t key_size, void *val, size_t val_size,
1270
+ upb_arena *arena) {
1271
+ upb_map **map = PTR_AT(msg, ofs, upb_map *);
1272
+ if (!*map) {
1273
+ *map = _upb_map_new(arena, key_size, val_size);
1274
+ }
1275
+ return _upb_map_set(*map, key, key_size, val, val_size, arena);
1276
+ }
1277
+
1278
+ UPB_INLINE bool _upb_msg_map_delete(upb_msg *msg, size_t ofs, const void *key,
1279
+ size_t key_size) {
1280
+ upb_map *map = *UPB_PTR_AT(msg, ofs, upb_map *);
1281
+ if (!map) return false;
1282
+ return _upb_map_delete(map, key, key_size);
1283
+ }
1284
+
1285
+ UPB_INLINE void _upb_msg_map_clear(upb_msg *msg, size_t ofs) {
1286
+ upb_map *map = *UPB_PTR_AT(msg, ofs, upb_map *);
1287
+ if (!map) return;
1288
+ _upb_map_clear(map);
1289
+ }
1290
+
1291
+ /* Accessing map key/value from a pointer, used by generated code only. */
1292
+
1293
+ UPB_INLINE void _upb_msg_map_key(const void* msg, void* key, size_t size) {
1294
+ const upb_tabent *ent = (const upb_tabent*)msg;
1295
+ uint32_t u32len;
1296
+ upb_strview k;
1297
+ k.data = upb_tabstr(ent->key, &u32len);
1298
+ k.size = u32len;
1299
+ _upb_map_fromkey(k, key, size);
1300
+ }
1301
+
1302
+ UPB_INLINE void _upb_msg_map_value(const void* msg, void* val, size_t size) {
1303
+ const upb_tabent *ent = (const upb_tabent*)msg;
1304
+ upb_value v;
1305
+ _upb_value_setval(&v, ent->val.val);
1306
+ _upb_map_fromvalue(v, val, size);
1307
+ }
1308
+
1309
+ UPB_INLINE void _upb_msg_map_set_value(void* msg, const void* val, size_t size) {
1310
+ upb_tabent *ent = (upb_tabent*)msg;
1311
+ /* This is like _upb_map_tovalue() except the entry already exists so we can
1312
+ * reuse the allocated upb_strview for string fields. */
1313
+ if (size == UPB_MAPTYPE_STRING) {
1314
+ upb_strview *strp = (upb_strview*)ent->val.val;
1315
+ memcpy(strp, val, sizeof(*strp));
1316
+ } else {
1317
+ memcpy(&ent->val.val, val, size);
1318
+ }
1235
1319
  }
1236
1320
 
1237
1321
  #undef PTR_AT
1238
1322
 
1323
+ #ifdef __cplusplus
1324
+ } /* extern "C" */
1325
+ #endif
1326
+
1327
+
1328
+ #endif /* UPB_MSG_H_ */
1329
+
1330
+ #ifdef __cplusplus
1331
+ extern "C" {
1332
+ #endif
1333
+
1334
+ bool upb_decode(const char *buf, size_t size, upb_msg *msg,
1335
+ const upb_msglayout *l, upb_arena *arena);
1336
+
1337
+ #ifdef __cplusplus
1338
+ } /* extern "C" */
1339
+ #endif
1340
+
1341
+ #endif /* UPB_DECODE_H_ */
1342
+ /*
1343
+ ** upb_encode: parsing into a upb_msg using a upb_msglayout.
1344
+ */
1345
+
1346
+ #ifndef UPB_ENCODE_H_
1347
+ #define UPB_ENCODE_H_
1348
+
1349
+
1350
+ #ifdef __cplusplus
1351
+ extern "C" {
1352
+ #endif
1353
+
1354
+ char *upb_encode(const void *msg, const upb_msglayout *l, upb_arena *arena,
1355
+ size_t *size);
1356
+
1357
+ #ifdef __cplusplus
1358
+ } /* extern "C" */
1359
+ #endif
1360
+
1361
+ #endif /* UPB_ENCODE_H_ */
1362
+ /* This file was generated by upbc (the upb compiler) from the input
1363
+ * file:
1364
+ *
1365
+ * google/protobuf/descriptor.proto
1366
+ *
1367
+ * Do not edit -- your changes will be discarded when the file is
1368
+ * regenerated. */
1369
+
1370
+ #ifndef GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H_
1371
+ #define GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H_
1239
1372
 
1240
- #endif /* UPB_GENERATED_UTIL_H_ */
1241
1373
 
1242
1374
 
1243
1375
  #ifdef __cplusplus
@@ -1381,7 +1513,7 @@ typedef enum {
1381
1513
  /* google.protobuf.FileDescriptorSet */
1382
1514
 
1383
1515
  UPB_INLINE google_protobuf_FileDescriptorSet *google_protobuf_FileDescriptorSet_new(upb_arena *arena) {
1384
- return (google_protobuf_FileDescriptorSet *)upb_msg_new(&google_protobuf_FileDescriptorSet_msginit, arena);
1516
+ return (google_protobuf_FileDescriptorSet *)_upb_msg_new(&google_protobuf_FileDescriptorSet_msginit, arena);
1385
1517
  }
1386
1518
  UPB_INLINE google_protobuf_FileDescriptorSet *google_protobuf_FileDescriptorSet_parse(const char *buf, size_t size,
1387
1519
  upb_arena *arena) {
@@ -1392,16 +1524,17 @@ UPB_INLINE char *google_protobuf_FileDescriptorSet_serialize(const google_protob
1392
1524
  return upb_encode(msg, &google_protobuf_FileDescriptorSet_msginit, arena, len);
1393
1525
  }
1394
1526
 
1527
+ UPB_INLINE bool google_protobuf_FileDescriptorSet_has_file(const google_protobuf_FileDescriptorSet *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0)); }
1395
1528
  UPB_INLINE const google_protobuf_FileDescriptorProto* const* google_protobuf_FileDescriptorSet_file(const google_protobuf_FileDescriptorSet *msg, size_t *len) { return (const google_protobuf_FileDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len); }
1396
1529
 
1397
1530
  UPB_INLINE google_protobuf_FileDescriptorProto** google_protobuf_FileDescriptorSet_mutable_file(google_protobuf_FileDescriptorSet *msg, size_t *len) {
1398
1531
  return (google_protobuf_FileDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(0, 0), len);
1399
1532
  }
1400
1533
  UPB_INLINE google_protobuf_FileDescriptorProto** google_protobuf_FileDescriptorSet_resize_file(google_protobuf_FileDescriptorSet *msg, size_t len, upb_arena *arena) {
1401
- return (google_protobuf_FileDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(0, 0), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1534
+ return (google_protobuf_FileDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(0, 0), len, UPB_TYPE_MESSAGE, arena);
1402
1535
  }
1403
1536
  UPB_INLINE struct google_protobuf_FileDescriptorProto* google_protobuf_FileDescriptorSet_add_file(google_protobuf_FileDescriptorSet *msg, upb_arena *arena) {
1404
- struct google_protobuf_FileDescriptorProto* sub = (struct google_protobuf_FileDescriptorProto*)upb_msg_new(&google_protobuf_FileDescriptorProto_msginit, arena);
1537
+ struct google_protobuf_FileDescriptorProto* sub = (struct google_protobuf_FileDescriptorProto*)_upb_msg_new(&google_protobuf_FileDescriptorProto_msginit, arena);
1405
1538
  bool ok = _upb_array_append_accessor(
1406
1539
  msg, UPB_SIZE(0, 0), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1407
1540
  if (!ok) return NULL;
@@ -1411,7 +1544,7 @@ UPB_INLINE struct google_protobuf_FileDescriptorProto* google_protobuf_FileDescr
1411
1544
  /* google.protobuf.FileDescriptorProto */
1412
1545
 
1413
1546
  UPB_INLINE google_protobuf_FileDescriptorProto *google_protobuf_FileDescriptorProto_new(upb_arena *arena) {
1414
- return (google_protobuf_FileDescriptorProto *)upb_msg_new(&google_protobuf_FileDescriptorProto_msginit, arena);
1547
+ return (google_protobuf_FileDescriptorProto *)_upb_msg_new(&google_protobuf_FileDescriptorProto_msginit, arena);
1415
1548
  }
1416
1549
  UPB_INLINE google_protobuf_FileDescriptorProto *google_protobuf_FileDescriptorProto_parse(const char *buf, size_t size,
1417
1550
  upb_arena *arena) {
@@ -1423,49 +1556,53 @@ UPB_INLINE char *google_protobuf_FileDescriptorProto_serialize(const google_prot
1423
1556
  }
1424
1557
 
1425
1558
  UPB_INLINE bool google_protobuf_FileDescriptorProto_has_name(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_field(msg, 1); }
1426
- UPB_INLINE upb_strview google_protobuf_FileDescriptorProto_name(const google_protobuf_FileDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)); }
1559
+ UPB_INLINE upb_strview google_protobuf_FileDescriptorProto_name(const google_protobuf_FileDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
1427
1560
  UPB_INLINE bool google_protobuf_FileDescriptorProto_has_package(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_field(msg, 2); }
1428
- UPB_INLINE upb_strview google_protobuf_FileDescriptorProto_package(const google_protobuf_FileDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(12, 24)); }
1561
+ UPB_INLINE upb_strview google_protobuf_FileDescriptorProto_package(const google_protobuf_FileDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_strview); }
1429
1562
  UPB_INLINE upb_strview const* google_protobuf_FileDescriptorProto_dependency(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (upb_strview const*)_upb_array_accessor(msg, UPB_SIZE(36, 72), len); }
1563
+ UPB_INLINE bool google_protobuf_FileDescriptorProto_has_message_type(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(40, 80)); }
1430
1564
  UPB_INLINE const google_protobuf_DescriptorProto* const* google_protobuf_FileDescriptorProto_message_type(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (const google_protobuf_DescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(40, 80), len); }
1565
+ UPB_INLINE bool google_protobuf_FileDescriptorProto_has_enum_type(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(44, 88)); }
1431
1566
  UPB_INLINE const google_protobuf_EnumDescriptorProto* const* google_protobuf_FileDescriptorProto_enum_type(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (const google_protobuf_EnumDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(44, 88), len); }
1567
+ UPB_INLINE bool google_protobuf_FileDescriptorProto_has_service(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(48, 96)); }
1432
1568
  UPB_INLINE const google_protobuf_ServiceDescriptorProto* const* google_protobuf_FileDescriptorProto_service(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (const google_protobuf_ServiceDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(48, 96), len); }
1569
+ UPB_INLINE bool google_protobuf_FileDescriptorProto_has_extension(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(52, 104)); }
1433
1570
  UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_FileDescriptorProto_extension(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(52, 104), len); }
1434
1571
  UPB_INLINE bool google_protobuf_FileDescriptorProto_has_options(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_field(msg, 4); }
1435
- UPB_INLINE const google_protobuf_FileOptions* google_protobuf_FileDescriptorProto_options(const google_protobuf_FileDescriptorProto *msg) { return UPB_FIELD_AT(msg, const google_protobuf_FileOptions*, UPB_SIZE(28, 56)); }
1572
+ UPB_INLINE const google_protobuf_FileOptions* google_protobuf_FileDescriptorProto_options(const google_protobuf_FileDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(28, 56), const google_protobuf_FileOptions*); }
1436
1573
  UPB_INLINE bool google_protobuf_FileDescriptorProto_has_source_code_info(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_field(msg, 5); }
1437
- UPB_INLINE const google_protobuf_SourceCodeInfo* google_protobuf_FileDescriptorProto_source_code_info(const google_protobuf_FileDescriptorProto *msg) { return UPB_FIELD_AT(msg, const google_protobuf_SourceCodeInfo*, UPB_SIZE(32, 64)); }
1574
+ UPB_INLINE const google_protobuf_SourceCodeInfo* google_protobuf_FileDescriptorProto_source_code_info(const google_protobuf_FileDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 64), const google_protobuf_SourceCodeInfo*); }
1438
1575
  UPB_INLINE int32_t const* google_protobuf_FileDescriptorProto_public_dependency(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(56, 112), len); }
1439
1576
  UPB_INLINE int32_t const* google_protobuf_FileDescriptorProto_weak_dependency(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(60, 120), len); }
1440
1577
  UPB_INLINE bool google_protobuf_FileDescriptorProto_has_syntax(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_field(msg, 3); }
1441
- UPB_INLINE upb_strview google_protobuf_FileDescriptorProto_syntax(const google_protobuf_FileDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(20, 40)); }
1578
+ UPB_INLINE upb_strview google_protobuf_FileDescriptorProto_syntax(const google_protobuf_FileDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_strview); }
1442
1579
 
1443
1580
  UPB_INLINE void google_protobuf_FileDescriptorProto_set_name(google_protobuf_FileDescriptorProto *msg, upb_strview value) {
1444
1581
  _upb_sethas(msg, 1);
1445
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)) = value;
1582
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview) = value;
1446
1583
  }
1447
1584
  UPB_INLINE void google_protobuf_FileDescriptorProto_set_package(google_protobuf_FileDescriptorProto *msg, upb_strview value) {
1448
1585
  _upb_sethas(msg, 2);
1449
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(12, 24)) = value;
1586
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_strview) = value;
1450
1587
  }
1451
1588
  UPB_INLINE upb_strview* google_protobuf_FileDescriptorProto_mutable_dependency(google_protobuf_FileDescriptorProto *msg, size_t *len) {
1452
1589
  return (upb_strview*)_upb_array_mutable_accessor(msg, UPB_SIZE(36, 72), len);
1453
1590
  }
1454
1591
  UPB_INLINE upb_strview* google_protobuf_FileDescriptorProto_resize_dependency(google_protobuf_FileDescriptorProto *msg, size_t len, upb_arena *arena) {
1455
- return (upb_strview*)_upb_array_resize_accessor(msg, UPB_SIZE(36, 72), len, UPB_SIZE(8, 16), UPB_TYPE_STRING, arena);
1592
+ return (upb_strview*)_upb_array_resize_accessor(msg, UPB_SIZE(36, 72), len, UPB_TYPE_STRING, arena);
1456
1593
  }
1457
1594
  UPB_INLINE bool google_protobuf_FileDescriptorProto_add_dependency(google_protobuf_FileDescriptorProto *msg, upb_strview val, upb_arena *arena) {
1458
- return _upb_array_append_accessor(
1459
- msg, UPB_SIZE(36, 72), UPB_SIZE(8, 16), UPB_TYPE_STRING, &val, arena);
1595
+ return _upb_array_append_accessor(msg, UPB_SIZE(36, 72), UPB_SIZE(8, 16), UPB_TYPE_STRING, &val,
1596
+ arena);
1460
1597
  }
1461
1598
  UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_FileDescriptorProto_mutable_message_type(google_protobuf_FileDescriptorProto *msg, size_t *len) {
1462
1599
  return (google_protobuf_DescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(40, 80), len);
1463
1600
  }
1464
1601
  UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_FileDescriptorProto_resize_message_type(google_protobuf_FileDescriptorProto *msg, size_t len, upb_arena *arena) {
1465
- return (google_protobuf_DescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(40, 80), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1602
+ return (google_protobuf_DescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(40, 80), len, UPB_TYPE_MESSAGE, arena);
1466
1603
  }
1467
1604
  UPB_INLINE struct google_protobuf_DescriptorProto* google_protobuf_FileDescriptorProto_add_message_type(google_protobuf_FileDescriptorProto *msg, upb_arena *arena) {
1468
- struct google_protobuf_DescriptorProto* sub = (struct google_protobuf_DescriptorProto*)upb_msg_new(&google_protobuf_DescriptorProto_msginit, arena);
1605
+ struct google_protobuf_DescriptorProto* sub = (struct google_protobuf_DescriptorProto*)_upb_msg_new(&google_protobuf_DescriptorProto_msginit, arena);
1469
1606
  bool ok = _upb_array_append_accessor(
1470
1607
  msg, UPB_SIZE(40, 80), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1471
1608
  if (!ok) return NULL;
@@ -1475,10 +1612,10 @@ UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_FileDescriptorP
1475
1612
  return (google_protobuf_EnumDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(44, 88), len);
1476
1613
  }
1477
1614
  UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_FileDescriptorProto_resize_enum_type(google_protobuf_FileDescriptorProto *msg, size_t len, upb_arena *arena) {
1478
- return (google_protobuf_EnumDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(44, 88), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1615
+ return (google_protobuf_EnumDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(44, 88), len, UPB_TYPE_MESSAGE, arena);
1479
1616
  }
1480
1617
  UPB_INLINE struct google_protobuf_EnumDescriptorProto* google_protobuf_FileDescriptorProto_add_enum_type(google_protobuf_FileDescriptorProto *msg, upb_arena *arena) {
1481
- struct google_protobuf_EnumDescriptorProto* sub = (struct google_protobuf_EnumDescriptorProto*)upb_msg_new(&google_protobuf_EnumDescriptorProto_msginit, arena);
1618
+ struct google_protobuf_EnumDescriptorProto* sub = (struct google_protobuf_EnumDescriptorProto*)_upb_msg_new(&google_protobuf_EnumDescriptorProto_msginit, arena);
1482
1619
  bool ok = _upb_array_append_accessor(
1483
1620
  msg, UPB_SIZE(44, 88), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1484
1621
  if (!ok) return NULL;
@@ -1488,10 +1625,10 @@ UPB_INLINE google_protobuf_ServiceDescriptorProto** google_protobuf_FileDescript
1488
1625
  return (google_protobuf_ServiceDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(48, 96), len);
1489
1626
  }
1490
1627
  UPB_INLINE google_protobuf_ServiceDescriptorProto** google_protobuf_FileDescriptorProto_resize_service(google_protobuf_FileDescriptorProto *msg, size_t len, upb_arena *arena) {
1491
- return (google_protobuf_ServiceDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(48, 96), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1628
+ return (google_protobuf_ServiceDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(48, 96), len, UPB_TYPE_MESSAGE, arena);
1492
1629
  }
1493
1630
  UPB_INLINE struct google_protobuf_ServiceDescriptorProto* google_protobuf_FileDescriptorProto_add_service(google_protobuf_FileDescriptorProto *msg, upb_arena *arena) {
1494
- struct google_protobuf_ServiceDescriptorProto* sub = (struct google_protobuf_ServiceDescriptorProto*)upb_msg_new(&google_protobuf_ServiceDescriptorProto_msginit, arena);
1631
+ struct google_protobuf_ServiceDescriptorProto* sub = (struct google_protobuf_ServiceDescriptorProto*)_upb_msg_new(&google_protobuf_ServiceDescriptorProto_msginit, arena);
1495
1632
  bool ok = _upb_array_append_accessor(
1496
1633
  msg, UPB_SIZE(48, 96), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1497
1634
  if (!ok) return NULL;
@@ -1501,10 +1638,10 @@ UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_FileDescriptor
1501
1638
  return (google_protobuf_FieldDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 104), len);
1502
1639
  }
1503
1640
  UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_FileDescriptorProto_resize_extension(google_protobuf_FileDescriptorProto *msg, size_t len, upb_arena *arena) {
1504
- return (google_protobuf_FieldDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(52, 104), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1641
+ return (google_protobuf_FieldDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(52, 104), len, UPB_TYPE_MESSAGE, arena);
1505
1642
  }
1506
1643
  UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_FileDescriptorProto_add_extension(google_protobuf_FileDescriptorProto *msg, upb_arena *arena) {
1507
- struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)upb_msg_new(&google_protobuf_FieldDescriptorProto_msginit, arena);
1644
+ struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)_upb_msg_new(&google_protobuf_FieldDescriptorProto_msginit, arena);
1508
1645
  bool ok = _upb_array_append_accessor(
1509
1646
  msg, UPB_SIZE(52, 104), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1510
1647
  if (!ok) return NULL;
@@ -1512,12 +1649,12 @@ UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_FileDesc
1512
1649
  }
1513
1650
  UPB_INLINE void google_protobuf_FileDescriptorProto_set_options(google_protobuf_FileDescriptorProto *msg, google_protobuf_FileOptions* value) {
1514
1651
  _upb_sethas(msg, 4);
1515
- UPB_FIELD_AT(msg, google_protobuf_FileOptions*, UPB_SIZE(28, 56)) = value;
1652
+ *UPB_PTR_AT(msg, UPB_SIZE(28, 56), google_protobuf_FileOptions*) = value;
1516
1653
  }
1517
1654
  UPB_INLINE struct google_protobuf_FileOptions* google_protobuf_FileDescriptorProto_mutable_options(google_protobuf_FileDescriptorProto *msg, upb_arena *arena) {
1518
1655
  struct google_protobuf_FileOptions* sub = (struct google_protobuf_FileOptions*)google_protobuf_FileDescriptorProto_options(msg);
1519
1656
  if (sub == NULL) {
1520
- sub = (struct google_protobuf_FileOptions*)upb_msg_new(&google_protobuf_FileOptions_msginit, arena);
1657
+ sub = (struct google_protobuf_FileOptions*)_upb_msg_new(&google_protobuf_FileOptions_msginit, arena);
1521
1658
  if (!sub) return NULL;
1522
1659
  google_protobuf_FileDescriptorProto_set_options(msg, sub);
1523
1660
  }
@@ -1525,12 +1662,12 @@ UPB_INLINE struct google_protobuf_FileOptions* google_protobuf_FileDescriptorPro
1525
1662
  }
1526
1663
  UPB_INLINE void google_protobuf_FileDescriptorProto_set_source_code_info(google_protobuf_FileDescriptorProto *msg, google_protobuf_SourceCodeInfo* value) {
1527
1664
  _upb_sethas(msg, 5);
1528
- UPB_FIELD_AT(msg, google_protobuf_SourceCodeInfo*, UPB_SIZE(32, 64)) = value;
1665
+ *UPB_PTR_AT(msg, UPB_SIZE(32, 64), google_protobuf_SourceCodeInfo*) = value;
1529
1666
  }
1530
1667
  UPB_INLINE struct google_protobuf_SourceCodeInfo* google_protobuf_FileDescriptorProto_mutable_source_code_info(google_protobuf_FileDescriptorProto *msg, upb_arena *arena) {
1531
1668
  struct google_protobuf_SourceCodeInfo* sub = (struct google_protobuf_SourceCodeInfo*)google_protobuf_FileDescriptorProto_source_code_info(msg);
1532
1669
  if (sub == NULL) {
1533
- sub = (struct google_protobuf_SourceCodeInfo*)upb_msg_new(&google_protobuf_SourceCodeInfo_msginit, arena);
1670
+ sub = (struct google_protobuf_SourceCodeInfo*)_upb_msg_new(&google_protobuf_SourceCodeInfo_msginit, arena);
1534
1671
  if (!sub) return NULL;
1535
1672
  google_protobuf_FileDescriptorProto_set_source_code_info(msg, sub);
1536
1673
  }
@@ -1540,31 +1677,31 @@ UPB_INLINE int32_t* google_protobuf_FileDescriptorProto_mutable_public_dependenc
1540
1677
  return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 112), len);
1541
1678
  }
1542
1679
  UPB_INLINE int32_t* google_protobuf_FileDescriptorProto_resize_public_dependency(google_protobuf_FileDescriptorProto *msg, size_t len, upb_arena *arena) {
1543
- return (int32_t*)_upb_array_resize_accessor(msg, UPB_SIZE(56, 112), len, UPB_SIZE(4, 4), UPB_TYPE_INT32, arena);
1680
+ return (int32_t*)_upb_array_resize_accessor(msg, UPB_SIZE(56, 112), len, UPB_TYPE_INT32, arena);
1544
1681
  }
1545
1682
  UPB_INLINE bool google_protobuf_FileDescriptorProto_add_public_dependency(google_protobuf_FileDescriptorProto *msg, int32_t val, upb_arena *arena) {
1546
- return _upb_array_append_accessor(
1547
- msg, UPB_SIZE(56, 112), UPB_SIZE(4, 4), UPB_TYPE_INT32, &val, arena);
1683
+ return _upb_array_append_accessor(msg, UPB_SIZE(56, 112), UPB_SIZE(4, 4), UPB_TYPE_INT32, &val,
1684
+ arena);
1548
1685
  }
1549
1686
  UPB_INLINE int32_t* google_protobuf_FileDescriptorProto_mutable_weak_dependency(google_protobuf_FileDescriptorProto *msg, size_t *len) {
1550
1687
  return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(60, 120), len);
1551
1688
  }
1552
1689
  UPB_INLINE int32_t* google_protobuf_FileDescriptorProto_resize_weak_dependency(google_protobuf_FileDescriptorProto *msg, size_t len, upb_arena *arena) {
1553
- return (int32_t*)_upb_array_resize_accessor(msg, UPB_SIZE(60, 120), len, UPB_SIZE(4, 4), UPB_TYPE_INT32, arena);
1690
+ return (int32_t*)_upb_array_resize_accessor(msg, UPB_SIZE(60, 120), len, UPB_TYPE_INT32, arena);
1554
1691
  }
1555
1692
  UPB_INLINE bool google_protobuf_FileDescriptorProto_add_weak_dependency(google_protobuf_FileDescriptorProto *msg, int32_t val, upb_arena *arena) {
1556
- return _upb_array_append_accessor(
1557
- msg, UPB_SIZE(60, 120), UPB_SIZE(4, 4), UPB_TYPE_INT32, &val, arena);
1693
+ return _upb_array_append_accessor(msg, UPB_SIZE(60, 120), UPB_SIZE(4, 4), UPB_TYPE_INT32, &val,
1694
+ arena);
1558
1695
  }
1559
1696
  UPB_INLINE void google_protobuf_FileDescriptorProto_set_syntax(google_protobuf_FileDescriptorProto *msg, upb_strview value) {
1560
1697
  _upb_sethas(msg, 3);
1561
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(20, 40)) = value;
1698
+ *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_strview) = value;
1562
1699
  }
1563
1700
 
1564
1701
  /* google.protobuf.DescriptorProto */
1565
1702
 
1566
1703
  UPB_INLINE google_protobuf_DescriptorProto *google_protobuf_DescriptorProto_new(upb_arena *arena) {
1567
- return (google_protobuf_DescriptorProto *)upb_msg_new(&google_protobuf_DescriptorProto_msginit, arena);
1704
+ return (google_protobuf_DescriptorProto *)_upb_msg_new(&google_protobuf_DescriptorProto_msginit, arena);
1568
1705
  }
1569
1706
  UPB_INLINE google_protobuf_DescriptorProto *google_protobuf_DescriptorProto_parse(const char *buf, size_t size,
1570
1707
  upb_arena *arena) {
@@ -1576,30 +1713,37 @@ UPB_INLINE char *google_protobuf_DescriptorProto_serialize(const google_protobuf
1576
1713
  }
1577
1714
 
1578
1715
  UPB_INLINE bool google_protobuf_DescriptorProto_has_name(const google_protobuf_DescriptorProto *msg) { return _upb_has_field(msg, 1); }
1579
- UPB_INLINE upb_strview google_protobuf_DescriptorProto_name(const google_protobuf_DescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)); }
1716
+ UPB_INLINE upb_strview google_protobuf_DescriptorProto_name(const google_protobuf_DescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
1717
+ UPB_INLINE bool google_protobuf_DescriptorProto_has_field(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(16, 32)); }
1580
1718
  UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_DescriptorProto_field(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(16, 32), len); }
1719
+ UPB_INLINE bool google_protobuf_DescriptorProto_has_nested_type(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(20, 40)); }
1581
1720
  UPB_INLINE const google_protobuf_DescriptorProto* const* google_protobuf_DescriptorProto_nested_type(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_DescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(20, 40), len); }
1721
+ UPB_INLINE bool google_protobuf_DescriptorProto_has_enum_type(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(24, 48)); }
1582
1722
  UPB_INLINE const google_protobuf_EnumDescriptorProto* const* google_protobuf_DescriptorProto_enum_type(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_EnumDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len); }
1723
+ UPB_INLINE bool google_protobuf_DescriptorProto_has_extension_range(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(28, 56)); }
1583
1724
  UPB_INLINE const google_protobuf_DescriptorProto_ExtensionRange* const* google_protobuf_DescriptorProto_extension_range(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_DescriptorProto_ExtensionRange* const*)_upb_array_accessor(msg, UPB_SIZE(28, 56), len); }
1725
+ UPB_INLINE bool google_protobuf_DescriptorProto_has_extension(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(32, 64)); }
1584
1726
  UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_DescriptorProto_extension(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(32, 64), len); }
1585
1727
  UPB_INLINE bool google_protobuf_DescriptorProto_has_options(const google_protobuf_DescriptorProto *msg) { return _upb_has_field(msg, 2); }
1586
- UPB_INLINE const google_protobuf_MessageOptions* google_protobuf_DescriptorProto_options(const google_protobuf_DescriptorProto *msg) { return UPB_FIELD_AT(msg, const google_protobuf_MessageOptions*, UPB_SIZE(12, 24)); }
1728
+ UPB_INLINE const google_protobuf_MessageOptions* google_protobuf_DescriptorProto_options(const google_protobuf_DescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_MessageOptions*); }
1729
+ UPB_INLINE bool google_protobuf_DescriptorProto_has_oneof_decl(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(36, 72)); }
1587
1730
  UPB_INLINE const google_protobuf_OneofDescriptorProto* const* google_protobuf_DescriptorProto_oneof_decl(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_OneofDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(36, 72), len); }
1731
+ UPB_INLINE bool google_protobuf_DescriptorProto_has_reserved_range(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(40, 80)); }
1588
1732
  UPB_INLINE const google_protobuf_DescriptorProto_ReservedRange* const* google_protobuf_DescriptorProto_reserved_range(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_DescriptorProto_ReservedRange* const*)_upb_array_accessor(msg, UPB_SIZE(40, 80), len); }
1589
1733
  UPB_INLINE upb_strview const* google_protobuf_DescriptorProto_reserved_name(const google_protobuf_DescriptorProto *msg, size_t *len) { return (upb_strview const*)_upb_array_accessor(msg, UPB_SIZE(44, 88), len); }
1590
1734
 
1591
1735
  UPB_INLINE void google_protobuf_DescriptorProto_set_name(google_protobuf_DescriptorProto *msg, upb_strview value) {
1592
1736
  _upb_sethas(msg, 1);
1593
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)) = value;
1737
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview) = value;
1594
1738
  }
1595
1739
  UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProto_mutable_field(google_protobuf_DescriptorProto *msg, size_t *len) {
1596
1740
  return (google_protobuf_FieldDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(16, 32), len);
1597
1741
  }
1598
1742
  UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProto_resize_field(google_protobuf_DescriptorProto *msg, size_t len, upb_arena *arena) {
1599
- return (google_protobuf_FieldDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(16, 32), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1743
+ return (google_protobuf_FieldDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(16, 32), len, UPB_TYPE_MESSAGE, arena);
1600
1744
  }
1601
1745
  UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_DescriptorProto_add_field(google_protobuf_DescriptorProto *msg, upb_arena *arena) {
1602
- struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)upb_msg_new(&google_protobuf_FieldDescriptorProto_msginit, arena);
1746
+ struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)_upb_msg_new(&google_protobuf_FieldDescriptorProto_msginit, arena);
1603
1747
  bool ok = _upb_array_append_accessor(
1604
1748
  msg, UPB_SIZE(16, 32), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1605
1749
  if (!ok) return NULL;
@@ -1609,10 +1753,10 @@ UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_DescriptorProto_mut
1609
1753
  return (google_protobuf_DescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(20, 40), len);
1610
1754
  }
1611
1755
  UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_DescriptorProto_resize_nested_type(google_protobuf_DescriptorProto *msg, size_t len, upb_arena *arena) {
1612
- return (google_protobuf_DescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(20, 40), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1756
+ return (google_protobuf_DescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(20, 40), len, UPB_TYPE_MESSAGE, arena);
1613
1757
  }
1614
1758
  UPB_INLINE struct google_protobuf_DescriptorProto* google_protobuf_DescriptorProto_add_nested_type(google_protobuf_DescriptorProto *msg, upb_arena *arena) {
1615
- struct google_protobuf_DescriptorProto* sub = (struct google_protobuf_DescriptorProto*)upb_msg_new(&google_protobuf_DescriptorProto_msginit, arena);
1759
+ struct google_protobuf_DescriptorProto* sub = (struct google_protobuf_DescriptorProto*)_upb_msg_new(&google_protobuf_DescriptorProto_msginit, arena);
1616
1760
  bool ok = _upb_array_append_accessor(
1617
1761
  msg, UPB_SIZE(20, 40), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1618
1762
  if (!ok) return NULL;
@@ -1622,10 +1766,10 @@ UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_DescriptorProto
1622
1766
  return (google_protobuf_EnumDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 48), len);
1623
1767
  }
1624
1768
  UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_DescriptorProto_resize_enum_type(google_protobuf_DescriptorProto *msg, size_t len, upb_arena *arena) {
1625
- return (google_protobuf_EnumDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(24, 48), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1769
+ return (google_protobuf_EnumDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(24, 48), len, UPB_TYPE_MESSAGE, arena);
1626
1770
  }
1627
1771
  UPB_INLINE struct google_protobuf_EnumDescriptorProto* google_protobuf_DescriptorProto_add_enum_type(google_protobuf_DescriptorProto *msg, upb_arena *arena) {
1628
- struct google_protobuf_EnumDescriptorProto* sub = (struct google_protobuf_EnumDescriptorProto*)upb_msg_new(&google_protobuf_EnumDescriptorProto_msginit, arena);
1772
+ struct google_protobuf_EnumDescriptorProto* sub = (struct google_protobuf_EnumDescriptorProto*)_upb_msg_new(&google_protobuf_EnumDescriptorProto_msginit, arena);
1629
1773
  bool ok = _upb_array_append_accessor(
1630
1774
  msg, UPB_SIZE(24, 48), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1631
1775
  if (!ok) return NULL;
@@ -1635,10 +1779,10 @@ UPB_INLINE google_protobuf_DescriptorProto_ExtensionRange** google_protobuf_Desc
1635
1779
  return (google_protobuf_DescriptorProto_ExtensionRange**)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 56), len);
1636
1780
  }
1637
1781
  UPB_INLINE google_protobuf_DescriptorProto_ExtensionRange** google_protobuf_DescriptorProto_resize_extension_range(google_protobuf_DescriptorProto *msg, size_t len, upb_arena *arena) {
1638
- return (google_protobuf_DescriptorProto_ExtensionRange**)_upb_array_resize_accessor(msg, UPB_SIZE(28, 56), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1782
+ return (google_protobuf_DescriptorProto_ExtensionRange**)_upb_array_resize_accessor(msg, UPB_SIZE(28, 56), len, UPB_TYPE_MESSAGE, arena);
1639
1783
  }
1640
1784
  UPB_INLINE struct google_protobuf_DescriptorProto_ExtensionRange* google_protobuf_DescriptorProto_add_extension_range(google_protobuf_DescriptorProto *msg, upb_arena *arena) {
1641
- struct google_protobuf_DescriptorProto_ExtensionRange* sub = (struct google_protobuf_DescriptorProto_ExtensionRange*)upb_msg_new(&google_protobuf_DescriptorProto_ExtensionRange_msginit, arena);
1785
+ struct google_protobuf_DescriptorProto_ExtensionRange* sub = (struct google_protobuf_DescriptorProto_ExtensionRange*)_upb_msg_new(&google_protobuf_DescriptorProto_ExtensionRange_msginit, arena);
1642
1786
  bool ok = _upb_array_append_accessor(
1643
1787
  msg, UPB_SIZE(28, 56), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1644
1788
  if (!ok) return NULL;
@@ -1648,10 +1792,10 @@ UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProt
1648
1792
  return (google_protobuf_FieldDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(32, 64), len);
1649
1793
  }
1650
1794
  UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProto_resize_extension(google_protobuf_DescriptorProto *msg, size_t len, upb_arena *arena) {
1651
- return (google_protobuf_FieldDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(32, 64), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1795
+ return (google_protobuf_FieldDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(32, 64), len, UPB_TYPE_MESSAGE, arena);
1652
1796
  }
1653
1797
  UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_DescriptorProto_add_extension(google_protobuf_DescriptorProto *msg, upb_arena *arena) {
1654
- struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)upb_msg_new(&google_protobuf_FieldDescriptorProto_msginit, arena);
1798
+ struct google_protobuf_FieldDescriptorProto* sub = (struct google_protobuf_FieldDescriptorProto*)_upb_msg_new(&google_protobuf_FieldDescriptorProto_msginit, arena);
1655
1799
  bool ok = _upb_array_append_accessor(
1656
1800
  msg, UPB_SIZE(32, 64), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1657
1801
  if (!ok) return NULL;
@@ -1659,12 +1803,12 @@ UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_Descript
1659
1803
  }
1660
1804
  UPB_INLINE void google_protobuf_DescriptorProto_set_options(google_protobuf_DescriptorProto *msg, google_protobuf_MessageOptions* value) {
1661
1805
  _upb_sethas(msg, 2);
1662
- UPB_FIELD_AT(msg, google_protobuf_MessageOptions*, UPB_SIZE(12, 24)) = value;
1806
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), google_protobuf_MessageOptions*) = value;
1663
1807
  }
1664
1808
  UPB_INLINE struct google_protobuf_MessageOptions* google_protobuf_DescriptorProto_mutable_options(google_protobuf_DescriptorProto *msg, upb_arena *arena) {
1665
1809
  struct google_protobuf_MessageOptions* sub = (struct google_protobuf_MessageOptions*)google_protobuf_DescriptorProto_options(msg);
1666
1810
  if (sub == NULL) {
1667
- sub = (struct google_protobuf_MessageOptions*)upb_msg_new(&google_protobuf_MessageOptions_msginit, arena);
1811
+ sub = (struct google_protobuf_MessageOptions*)_upb_msg_new(&google_protobuf_MessageOptions_msginit, arena);
1668
1812
  if (!sub) return NULL;
1669
1813
  google_protobuf_DescriptorProto_set_options(msg, sub);
1670
1814
  }
@@ -1674,10 +1818,10 @@ UPB_INLINE google_protobuf_OneofDescriptorProto** google_protobuf_DescriptorProt
1674
1818
  return (google_protobuf_OneofDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(36, 72), len);
1675
1819
  }
1676
1820
  UPB_INLINE google_protobuf_OneofDescriptorProto** google_protobuf_DescriptorProto_resize_oneof_decl(google_protobuf_DescriptorProto *msg, size_t len, upb_arena *arena) {
1677
- return (google_protobuf_OneofDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(36, 72), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1821
+ return (google_protobuf_OneofDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(36, 72), len, UPB_TYPE_MESSAGE, arena);
1678
1822
  }
1679
1823
  UPB_INLINE struct google_protobuf_OneofDescriptorProto* google_protobuf_DescriptorProto_add_oneof_decl(google_protobuf_DescriptorProto *msg, upb_arena *arena) {
1680
- struct google_protobuf_OneofDescriptorProto* sub = (struct google_protobuf_OneofDescriptorProto*)upb_msg_new(&google_protobuf_OneofDescriptorProto_msginit, arena);
1824
+ struct google_protobuf_OneofDescriptorProto* sub = (struct google_protobuf_OneofDescriptorProto*)_upb_msg_new(&google_protobuf_OneofDescriptorProto_msginit, arena);
1681
1825
  bool ok = _upb_array_append_accessor(
1682
1826
  msg, UPB_SIZE(36, 72), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1683
1827
  if (!ok) return NULL;
@@ -1687,10 +1831,10 @@ UPB_INLINE google_protobuf_DescriptorProto_ReservedRange** google_protobuf_Descr
1687
1831
  return (google_protobuf_DescriptorProto_ReservedRange**)_upb_array_mutable_accessor(msg, UPB_SIZE(40, 80), len);
1688
1832
  }
1689
1833
  UPB_INLINE google_protobuf_DescriptorProto_ReservedRange** google_protobuf_DescriptorProto_resize_reserved_range(google_protobuf_DescriptorProto *msg, size_t len, upb_arena *arena) {
1690
- return (google_protobuf_DescriptorProto_ReservedRange**)_upb_array_resize_accessor(msg, UPB_SIZE(40, 80), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1834
+ return (google_protobuf_DescriptorProto_ReservedRange**)_upb_array_resize_accessor(msg, UPB_SIZE(40, 80), len, UPB_TYPE_MESSAGE, arena);
1691
1835
  }
1692
1836
  UPB_INLINE struct google_protobuf_DescriptorProto_ReservedRange* google_protobuf_DescriptorProto_add_reserved_range(google_protobuf_DescriptorProto *msg, upb_arena *arena) {
1693
- struct google_protobuf_DescriptorProto_ReservedRange* sub = (struct google_protobuf_DescriptorProto_ReservedRange*)upb_msg_new(&google_protobuf_DescriptorProto_ReservedRange_msginit, arena);
1837
+ struct google_protobuf_DescriptorProto_ReservedRange* sub = (struct google_protobuf_DescriptorProto_ReservedRange*)_upb_msg_new(&google_protobuf_DescriptorProto_ReservedRange_msginit, arena);
1694
1838
  bool ok = _upb_array_append_accessor(
1695
1839
  msg, UPB_SIZE(40, 80), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1696
1840
  if (!ok) return NULL;
@@ -1700,17 +1844,17 @@ UPB_INLINE upb_strview* google_protobuf_DescriptorProto_mutable_reserved_name(go
1700
1844
  return (upb_strview*)_upb_array_mutable_accessor(msg, UPB_SIZE(44, 88), len);
1701
1845
  }
1702
1846
  UPB_INLINE upb_strview* google_protobuf_DescriptorProto_resize_reserved_name(google_protobuf_DescriptorProto *msg, size_t len, upb_arena *arena) {
1703
- return (upb_strview*)_upb_array_resize_accessor(msg, UPB_SIZE(44, 88), len, UPB_SIZE(8, 16), UPB_TYPE_STRING, arena);
1847
+ return (upb_strview*)_upb_array_resize_accessor(msg, UPB_SIZE(44, 88), len, UPB_TYPE_STRING, arena);
1704
1848
  }
1705
1849
  UPB_INLINE bool google_protobuf_DescriptorProto_add_reserved_name(google_protobuf_DescriptorProto *msg, upb_strview val, upb_arena *arena) {
1706
- return _upb_array_append_accessor(
1707
- msg, UPB_SIZE(44, 88), UPB_SIZE(8, 16), UPB_TYPE_STRING, &val, arena);
1850
+ return _upb_array_append_accessor(msg, UPB_SIZE(44, 88), UPB_SIZE(8, 16), UPB_TYPE_STRING, &val,
1851
+ arena);
1708
1852
  }
1709
1853
 
1710
1854
  /* google.protobuf.DescriptorProto.ExtensionRange */
1711
1855
 
1712
1856
  UPB_INLINE google_protobuf_DescriptorProto_ExtensionRange *google_protobuf_DescriptorProto_ExtensionRange_new(upb_arena *arena) {
1713
- return (google_protobuf_DescriptorProto_ExtensionRange *)upb_msg_new(&google_protobuf_DescriptorProto_ExtensionRange_msginit, arena);
1857
+ return (google_protobuf_DescriptorProto_ExtensionRange *)_upb_msg_new(&google_protobuf_DescriptorProto_ExtensionRange_msginit, arena);
1714
1858
  }
1715
1859
  UPB_INLINE google_protobuf_DescriptorProto_ExtensionRange *google_protobuf_DescriptorProto_ExtensionRange_parse(const char *buf, size_t size,
1716
1860
  upb_arena *arena) {
@@ -1722,28 +1866,28 @@ UPB_INLINE char *google_protobuf_DescriptorProto_ExtensionRange_serialize(const
1722
1866
  }
1723
1867
 
1724
1868
  UPB_INLINE bool google_protobuf_DescriptorProto_ExtensionRange_has_start(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return _upb_has_field(msg, 1); }
1725
- UPB_INLINE int32_t google_protobuf_DescriptorProto_ExtensionRange_start(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(4, 4)); }
1869
+ UPB_INLINE int32_t google_protobuf_DescriptorProto_ExtensionRange_start(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t); }
1726
1870
  UPB_INLINE bool google_protobuf_DescriptorProto_ExtensionRange_has_end(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return _upb_has_field(msg, 2); }
1727
- UPB_INLINE int32_t google_protobuf_DescriptorProto_ExtensionRange_end(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)); }
1871
+ UPB_INLINE int32_t google_protobuf_DescriptorProto_ExtensionRange_end(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
1728
1872
  UPB_INLINE bool google_protobuf_DescriptorProto_ExtensionRange_has_options(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return _upb_has_field(msg, 3); }
1729
- UPB_INLINE const google_protobuf_ExtensionRangeOptions* google_protobuf_DescriptorProto_ExtensionRange_options(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return UPB_FIELD_AT(msg, const google_protobuf_ExtensionRangeOptions*, UPB_SIZE(12, 16)); }
1873
+ UPB_INLINE const google_protobuf_ExtensionRangeOptions* google_protobuf_DescriptorProto_ExtensionRange_options(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 16), const google_protobuf_ExtensionRangeOptions*); }
1730
1874
 
1731
1875
  UPB_INLINE void google_protobuf_DescriptorProto_ExtensionRange_set_start(google_protobuf_DescriptorProto_ExtensionRange *msg, int32_t value) {
1732
1876
  _upb_sethas(msg, 1);
1733
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(4, 4)) = value;
1877
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = value;
1734
1878
  }
1735
1879
  UPB_INLINE void google_protobuf_DescriptorProto_ExtensionRange_set_end(google_protobuf_DescriptorProto_ExtensionRange *msg, int32_t value) {
1736
1880
  _upb_sethas(msg, 2);
1737
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)) = value;
1881
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
1738
1882
  }
1739
1883
  UPB_INLINE void google_protobuf_DescriptorProto_ExtensionRange_set_options(google_protobuf_DescriptorProto_ExtensionRange *msg, google_protobuf_ExtensionRangeOptions* value) {
1740
1884
  _upb_sethas(msg, 3);
1741
- UPB_FIELD_AT(msg, google_protobuf_ExtensionRangeOptions*, UPB_SIZE(12, 16)) = value;
1885
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 16), google_protobuf_ExtensionRangeOptions*) = value;
1742
1886
  }
1743
1887
  UPB_INLINE struct google_protobuf_ExtensionRangeOptions* google_protobuf_DescriptorProto_ExtensionRange_mutable_options(google_protobuf_DescriptorProto_ExtensionRange *msg, upb_arena *arena) {
1744
1888
  struct google_protobuf_ExtensionRangeOptions* sub = (struct google_protobuf_ExtensionRangeOptions*)google_protobuf_DescriptorProto_ExtensionRange_options(msg);
1745
1889
  if (sub == NULL) {
1746
- sub = (struct google_protobuf_ExtensionRangeOptions*)upb_msg_new(&google_protobuf_ExtensionRangeOptions_msginit, arena);
1890
+ sub = (struct google_protobuf_ExtensionRangeOptions*)_upb_msg_new(&google_protobuf_ExtensionRangeOptions_msginit, arena);
1747
1891
  if (!sub) return NULL;
1748
1892
  google_protobuf_DescriptorProto_ExtensionRange_set_options(msg, sub);
1749
1893
  }
@@ -1753,7 +1897,7 @@ UPB_INLINE struct google_protobuf_ExtensionRangeOptions* google_protobuf_Descrip
1753
1897
  /* google.protobuf.DescriptorProto.ReservedRange */
1754
1898
 
1755
1899
  UPB_INLINE google_protobuf_DescriptorProto_ReservedRange *google_protobuf_DescriptorProto_ReservedRange_new(upb_arena *arena) {
1756
- return (google_protobuf_DescriptorProto_ReservedRange *)upb_msg_new(&google_protobuf_DescriptorProto_ReservedRange_msginit, arena);
1900
+ return (google_protobuf_DescriptorProto_ReservedRange *)_upb_msg_new(&google_protobuf_DescriptorProto_ReservedRange_msginit, arena);
1757
1901
  }
1758
1902
  UPB_INLINE google_protobuf_DescriptorProto_ReservedRange *google_protobuf_DescriptorProto_ReservedRange_parse(const char *buf, size_t size,
1759
1903
  upb_arena *arena) {
@@ -1765,23 +1909,23 @@ UPB_INLINE char *google_protobuf_DescriptorProto_ReservedRange_serialize(const g
1765
1909
  }
1766
1910
 
1767
1911
  UPB_INLINE bool google_protobuf_DescriptorProto_ReservedRange_has_start(const google_protobuf_DescriptorProto_ReservedRange *msg) { return _upb_has_field(msg, 1); }
1768
- UPB_INLINE int32_t google_protobuf_DescriptorProto_ReservedRange_start(const google_protobuf_DescriptorProto_ReservedRange *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(4, 4)); }
1912
+ UPB_INLINE int32_t google_protobuf_DescriptorProto_ReservedRange_start(const google_protobuf_DescriptorProto_ReservedRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t); }
1769
1913
  UPB_INLINE bool google_protobuf_DescriptorProto_ReservedRange_has_end(const google_protobuf_DescriptorProto_ReservedRange *msg) { return _upb_has_field(msg, 2); }
1770
- UPB_INLINE int32_t google_protobuf_DescriptorProto_ReservedRange_end(const google_protobuf_DescriptorProto_ReservedRange *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)); }
1914
+ UPB_INLINE int32_t google_protobuf_DescriptorProto_ReservedRange_end(const google_protobuf_DescriptorProto_ReservedRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
1771
1915
 
1772
1916
  UPB_INLINE void google_protobuf_DescriptorProto_ReservedRange_set_start(google_protobuf_DescriptorProto_ReservedRange *msg, int32_t value) {
1773
1917
  _upb_sethas(msg, 1);
1774
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(4, 4)) = value;
1918
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = value;
1775
1919
  }
1776
1920
  UPB_INLINE void google_protobuf_DescriptorProto_ReservedRange_set_end(google_protobuf_DescriptorProto_ReservedRange *msg, int32_t value) {
1777
1921
  _upb_sethas(msg, 2);
1778
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)) = value;
1922
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
1779
1923
  }
1780
1924
 
1781
1925
  /* google.protobuf.ExtensionRangeOptions */
1782
1926
 
1783
1927
  UPB_INLINE google_protobuf_ExtensionRangeOptions *google_protobuf_ExtensionRangeOptions_new(upb_arena *arena) {
1784
- return (google_protobuf_ExtensionRangeOptions *)upb_msg_new(&google_protobuf_ExtensionRangeOptions_msginit, arena);
1928
+ return (google_protobuf_ExtensionRangeOptions *)_upb_msg_new(&google_protobuf_ExtensionRangeOptions_msginit, arena);
1785
1929
  }
1786
1930
  UPB_INLINE google_protobuf_ExtensionRangeOptions *google_protobuf_ExtensionRangeOptions_parse(const char *buf, size_t size,
1787
1931
  upb_arena *arena) {
@@ -1792,16 +1936,17 @@ UPB_INLINE char *google_protobuf_ExtensionRangeOptions_serialize(const google_pr
1792
1936
  return upb_encode(msg, &google_protobuf_ExtensionRangeOptions_msginit, arena, len);
1793
1937
  }
1794
1938
 
1939
+ UPB_INLINE bool google_protobuf_ExtensionRangeOptions_has_uninterpreted_option(const google_protobuf_ExtensionRangeOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0)); }
1795
1940
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_ExtensionRangeOptions_uninterpreted_option(const google_protobuf_ExtensionRangeOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len); }
1796
1941
 
1797
1942
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_ExtensionRangeOptions_mutable_uninterpreted_option(google_protobuf_ExtensionRangeOptions *msg, size_t *len) {
1798
1943
  return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(0, 0), len);
1799
1944
  }
1800
1945
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_ExtensionRangeOptions_resize_uninterpreted_option(google_protobuf_ExtensionRangeOptions *msg, size_t len, upb_arena *arena) {
1801
- return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(0, 0), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
1946
+ return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(0, 0), len, UPB_TYPE_MESSAGE, arena);
1802
1947
  }
1803
1948
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_ExtensionRangeOptions_add_uninterpreted_option(google_protobuf_ExtensionRangeOptions *msg, upb_arena *arena) {
1804
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
1949
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
1805
1950
  bool ok = _upb_array_append_accessor(
1806
1951
  msg, UPB_SIZE(0, 0), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1807
1952
  if (!ok) return NULL;
@@ -1811,7 +1956,7 @@ UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_Extension
1811
1956
  /* google.protobuf.FieldDescriptorProto */
1812
1957
 
1813
1958
  UPB_INLINE google_protobuf_FieldDescriptorProto *google_protobuf_FieldDescriptorProto_new(upb_arena *arena) {
1814
- return (google_protobuf_FieldDescriptorProto *)upb_msg_new(&google_protobuf_FieldDescriptorProto_msginit, arena);
1959
+ return (google_protobuf_FieldDescriptorProto *)_upb_msg_new(&google_protobuf_FieldDescriptorProto_msginit, arena);
1815
1960
  }
1816
1961
  UPB_INLINE google_protobuf_FieldDescriptorProto *google_protobuf_FieldDescriptorProto_parse(const char *buf, size_t size,
1817
1962
  upb_arena *arena) {
@@ -1822,63 +1967,65 @@ UPB_INLINE char *google_protobuf_FieldDescriptorProto_serialize(const google_pro
1822
1967
  return upb_encode(msg, &google_protobuf_FieldDescriptorProto_msginit, arena, len);
1823
1968
  }
1824
1969
 
1825
- UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_name(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 5); }
1826
- UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_name(const google_protobuf_FieldDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(32, 32)); }
1827
- UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_extendee(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 6); }
1828
- UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_extendee(const google_protobuf_FieldDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(40, 48)); }
1970
+ UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_name(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 6); }
1971
+ UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_name(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(36, 40), upb_strview); }
1972
+ UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_extendee(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 7); }
1973
+ UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_extendee(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(44, 56), upb_strview); }
1829
1974
  UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_number(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 3); }
1830
- UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_number(const google_protobuf_FieldDescriptorProto *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(24, 24)); }
1975
+ UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_number(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), int32_t); }
1831
1976
  UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_label(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 1); }
1832
- UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_label(const google_protobuf_FieldDescriptorProto *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)); }
1977
+ UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_label(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
1833
1978
  UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_type(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 2); }
1834
- UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_type(const google_protobuf_FieldDescriptorProto *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(16, 16)); }
1835
- UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_type_name(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 7); }
1836
- UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_type_name(const google_protobuf_FieldDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(48, 64)); }
1837
- UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_default_value(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 8); }
1838
- UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_default_value(const google_protobuf_FieldDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(56, 80)); }
1839
- UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_options(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 10); }
1840
- UPB_INLINE const google_protobuf_FieldOptions* google_protobuf_FieldDescriptorProto_options(const google_protobuf_FieldDescriptorProto *msg) { return UPB_FIELD_AT(msg, const google_protobuf_FieldOptions*, UPB_SIZE(72, 112)); }
1979
+ UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_type(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t); }
1980
+ UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_type_name(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 8); }
1981
+ UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_type_name(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(52, 72), upb_strview); }
1982
+ UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_default_value(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 9); }
1983
+ UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_default_value(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(60, 88), upb_strview); }
1984
+ UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_options(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 11); }
1985
+ UPB_INLINE const google_protobuf_FieldOptions* google_protobuf_FieldDescriptorProto_options(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(76, 120), const google_protobuf_FieldOptions*); }
1841
1986
  UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_oneof_index(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 4); }
1842
- UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_oneof_index(const google_protobuf_FieldDescriptorProto *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(28, 28)); }
1843
- UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_json_name(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 9); }
1844
- UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_json_name(const google_protobuf_FieldDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(64, 96)); }
1987
+ UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_oneof_index(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(28, 28), int32_t); }
1988
+ UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_json_name(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 10); }
1989
+ UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_json_name(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(68, 104), upb_strview); }
1990
+ UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_proto3_optional(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 5); }
1991
+ UPB_INLINE bool google_protobuf_FieldDescriptorProto_proto3_optional(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), bool); }
1845
1992
 
1846
1993
  UPB_INLINE void google_protobuf_FieldDescriptorProto_set_name(google_protobuf_FieldDescriptorProto *msg, upb_strview value) {
1847
- _upb_sethas(msg, 5);
1848
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(32, 32)) = value;
1994
+ _upb_sethas(msg, 6);
1995
+ *UPB_PTR_AT(msg, UPB_SIZE(36, 40), upb_strview) = value;
1849
1996
  }
1850
1997
  UPB_INLINE void google_protobuf_FieldDescriptorProto_set_extendee(google_protobuf_FieldDescriptorProto *msg, upb_strview value) {
1851
- _upb_sethas(msg, 6);
1852
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(40, 48)) = value;
1998
+ _upb_sethas(msg, 7);
1999
+ *UPB_PTR_AT(msg, UPB_SIZE(44, 56), upb_strview) = value;
1853
2000
  }
1854
2001
  UPB_INLINE void google_protobuf_FieldDescriptorProto_set_number(google_protobuf_FieldDescriptorProto *msg, int32_t value) {
1855
2002
  _upb_sethas(msg, 3);
1856
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(24, 24)) = value;
2003
+ *UPB_PTR_AT(msg, UPB_SIZE(24, 24), int32_t) = value;
1857
2004
  }
1858
2005
  UPB_INLINE void google_protobuf_FieldDescriptorProto_set_label(google_protobuf_FieldDescriptorProto *msg, int32_t value) {
1859
2006
  _upb_sethas(msg, 1);
1860
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)) = value;
2007
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
1861
2008
  }
1862
2009
  UPB_INLINE void google_protobuf_FieldDescriptorProto_set_type(google_protobuf_FieldDescriptorProto *msg, int32_t value) {
1863
2010
  _upb_sethas(msg, 2);
1864
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(16, 16)) = value;
2011
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t) = value;
1865
2012
  }
1866
2013
  UPB_INLINE void google_protobuf_FieldDescriptorProto_set_type_name(google_protobuf_FieldDescriptorProto *msg, upb_strview value) {
1867
- _upb_sethas(msg, 7);
1868
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(48, 64)) = value;
2014
+ _upb_sethas(msg, 8);
2015
+ *UPB_PTR_AT(msg, UPB_SIZE(52, 72), upb_strview) = value;
1869
2016
  }
1870
2017
  UPB_INLINE void google_protobuf_FieldDescriptorProto_set_default_value(google_protobuf_FieldDescriptorProto *msg, upb_strview value) {
1871
- _upb_sethas(msg, 8);
1872
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(56, 80)) = value;
2018
+ _upb_sethas(msg, 9);
2019
+ *UPB_PTR_AT(msg, UPB_SIZE(60, 88), upb_strview) = value;
1873
2020
  }
1874
2021
  UPB_INLINE void google_protobuf_FieldDescriptorProto_set_options(google_protobuf_FieldDescriptorProto *msg, google_protobuf_FieldOptions* value) {
1875
- _upb_sethas(msg, 10);
1876
- UPB_FIELD_AT(msg, google_protobuf_FieldOptions*, UPB_SIZE(72, 112)) = value;
2022
+ _upb_sethas(msg, 11);
2023
+ *UPB_PTR_AT(msg, UPB_SIZE(76, 120), google_protobuf_FieldOptions*) = value;
1877
2024
  }
1878
2025
  UPB_INLINE struct google_protobuf_FieldOptions* google_protobuf_FieldDescriptorProto_mutable_options(google_protobuf_FieldDescriptorProto *msg, upb_arena *arena) {
1879
2026
  struct google_protobuf_FieldOptions* sub = (struct google_protobuf_FieldOptions*)google_protobuf_FieldDescriptorProto_options(msg);
1880
2027
  if (sub == NULL) {
1881
- sub = (struct google_protobuf_FieldOptions*)upb_msg_new(&google_protobuf_FieldOptions_msginit, arena);
2028
+ sub = (struct google_protobuf_FieldOptions*)_upb_msg_new(&google_protobuf_FieldOptions_msginit, arena);
1882
2029
  if (!sub) return NULL;
1883
2030
  google_protobuf_FieldDescriptorProto_set_options(msg, sub);
1884
2031
  }
@@ -1886,17 +2033,21 @@ UPB_INLINE struct google_protobuf_FieldOptions* google_protobuf_FieldDescriptorP
1886
2033
  }
1887
2034
  UPB_INLINE void google_protobuf_FieldDescriptorProto_set_oneof_index(google_protobuf_FieldDescriptorProto *msg, int32_t value) {
1888
2035
  _upb_sethas(msg, 4);
1889
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(28, 28)) = value;
2036
+ *UPB_PTR_AT(msg, UPB_SIZE(28, 28), int32_t) = value;
1890
2037
  }
1891
2038
  UPB_INLINE void google_protobuf_FieldDescriptorProto_set_json_name(google_protobuf_FieldDescriptorProto *msg, upb_strview value) {
1892
- _upb_sethas(msg, 9);
1893
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(64, 96)) = value;
2039
+ _upb_sethas(msg, 10);
2040
+ *UPB_PTR_AT(msg, UPB_SIZE(68, 104), upb_strview) = value;
2041
+ }
2042
+ UPB_INLINE void google_protobuf_FieldDescriptorProto_set_proto3_optional(google_protobuf_FieldDescriptorProto *msg, bool value) {
2043
+ _upb_sethas(msg, 5);
2044
+ *UPB_PTR_AT(msg, UPB_SIZE(32, 32), bool) = value;
1894
2045
  }
1895
2046
 
1896
2047
  /* google.protobuf.OneofDescriptorProto */
1897
2048
 
1898
2049
  UPB_INLINE google_protobuf_OneofDescriptorProto *google_protobuf_OneofDescriptorProto_new(upb_arena *arena) {
1899
- return (google_protobuf_OneofDescriptorProto *)upb_msg_new(&google_protobuf_OneofDescriptorProto_msginit, arena);
2050
+ return (google_protobuf_OneofDescriptorProto *)_upb_msg_new(&google_protobuf_OneofDescriptorProto_msginit, arena);
1900
2051
  }
1901
2052
  UPB_INLINE google_protobuf_OneofDescriptorProto *google_protobuf_OneofDescriptorProto_parse(const char *buf, size_t size,
1902
2053
  upb_arena *arena) {
@@ -1908,22 +2059,22 @@ UPB_INLINE char *google_protobuf_OneofDescriptorProto_serialize(const google_pro
1908
2059
  }
1909
2060
 
1910
2061
  UPB_INLINE bool google_protobuf_OneofDescriptorProto_has_name(const google_protobuf_OneofDescriptorProto *msg) { return _upb_has_field(msg, 1); }
1911
- UPB_INLINE upb_strview google_protobuf_OneofDescriptorProto_name(const google_protobuf_OneofDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)); }
2062
+ UPB_INLINE upb_strview google_protobuf_OneofDescriptorProto_name(const google_protobuf_OneofDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
1912
2063
  UPB_INLINE bool google_protobuf_OneofDescriptorProto_has_options(const google_protobuf_OneofDescriptorProto *msg) { return _upb_has_field(msg, 2); }
1913
- UPB_INLINE const google_protobuf_OneofOptions* google_protobuf_OneofDescriptorProto_options(const google_protobuf_OneofDescriptorProto *msg) { return UPB_FIELD_AT(msg, const google_protobuf_OneofOptions*, UPB_SIZE(12, 24)); }
2064
+ UPB_INLINE const google_protobuf_OneofOptions* google_protobuf_OneofDescriptorProto_options(const google_protobuf_OneofDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_OneofOptions*); }
1914
2065
 
1915
2066
  UPB_INLINE void google_protobuf_OneofDescriptorProto_set_name(google_protobuf_OneofDescriptorProto *msg, upb_strview value) {
1916
2067
  _upb_sethas(msg, 1);
1917
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)) = value;
2068
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview) = value;
1918
2069
  }
1919
2070
  UPB_INLINE void google_protobuf_OneofDescriptorProto_set_options(google_protobuf_OneofDescriptorProto *msg, google_protobuf_OneofOptions* value) {
1920
2071
  _upb_sethas(msg, 2);
1921
- UPB_FIELD_AT(msg, google_protobuf_OneofOptions*, UPB_SIZE(12, 24)) = value;
2072
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), google_protobuf_OneofOptions*) = value;
1922
2073
  }
1923
2074
  UPB_INLINE struct google_protobuf_OneofOptions* google_protobuf_OneofDescriptorProto_mutable_options(google_protobuf_OneofDescriptorProto *msg, upb_arena *arena) {
1924
2075
  struct google_protobuf_OneofOptions* sub = (struct google_protobuf_OneofOptions*)google_protobuf_OneofDescriptorProto_options(msg);
1925
2076
  if (sub == NULL) {
1926
- sub = (struct google_protobuf_OneofOptions*)upb_msg_new(&google_protobuf_OneofOptions_msginit, arena);
2077
+ sub = (struct google_protobuf_OneofOptions*)_upb_msg_new(&google_protobuf_OneofOptions_msginit, arena);
1927
2078
  if (!sub) return NULL;
1928
2079
  google_protobuf_OneofDescriptorProto_set_options(msg, sub);
1929
2080
  }
@@ -1933,7 +2084,7 @@ UPB_INLINE struct google_protobuf_OneofOptions* google_protobuf_OneofDescriptorP
1933
2084
  /* google.protobuf.EnumDescriptorProto */
1934
2085
 
1935
2086
  UPB_INLINE google_protobuf_EnumDescriptorProto *google_protobuf_EnumDescriptorProto_new(upb_arena *arena) {
1936
- return (google_protobuf_EnumDescriptorProto *)upb_msg_new(&google_protobuf_EnumDescriptorProto_msginit, arena);
2087
+ return (google_protobuf_EnumDescriptorProto *)_upb_msg_new(&google_protobuf_EnumDescriptorProto_msginit, arena);
1937
2088
  }
1938
2089
  UPB_INLINE google_protobuf_EnumDescriptorProto *google_protobuf_EnumDescriptorProto_parse(const char *buf, size_t size,
1939
2090
  upb_arena *arena) {
@@ -1945,25 +2096,27 @@ UPB_INLINE char *google_protobuf_EnumDescriptorProto_serialize(const google_prot
1945
2096
  }
1946
2097
 
1947
2098
  UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_name(const google_protobuf_EnumDescriptorProto *msg) { return _upb_has_field(msg, 1); }
1948
- UPB_INLINE upb_strview google_protobuf_EnumDescriptorProto_name(const google_protobuf_EnumDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)); }
2099
+ UPB_INLINE upb_strview google_protobuf_EnumDescriptorProto_name(const google_protobuf_EnumDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
2100
+ UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_value(const google_protobuf_EnumDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(16, 32)); }
1949
2101
  UPB_INLINE const google_protobuf_EnumValueDescriptorProto* const* google_protobuf_EnumDescriptorProto_value(const google_protobuf_EnumDescriptorProto *msg, size_t *len) { return (const google_protobuf_EnumValueDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(16, 32), len); }
1950
2102
  UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_options(const google_protobuf_EnumDescriptorProto *msg) { return _upb_has_field(msg, 2); }
1951
- UPB_INLINE const google_protobuf_EnumOptions* google_protobuf_EnumDescriptorProto_options(const google_protobuf_EnumDescriptorProto *msg) { return UPB_FIELD_AT(msg, const google_protobuf_EnumOptions*, UPB_SIZE(12, 24)); }
2103
+ UPB_INLINE const google_protobuf_EnumOptions* google_protobuf_EnumDescriptorProto_options(const google_protobuf_EnumDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_EnumOptions*); }
2104
+ UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_reserved_range(const google_protobuf_EnumDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(20, 40)); }
1952
2105
  UPB_INLINE const google_protobuf_EnumDescriptorProto_EnumReservedRange* const* google_protobuf_EnumDescriptorProto_reserved_range(const google_protobuf_EnumDescriptorProto *msg, size_t *len) { return (const google_protobuf_EnumDescriptorProto_EnumReservedRange* const*)_upb_array_accessor(msg, UPB_SIZE(20, 40), len); }
1953
2106
  UPB_INLINE upb_strview const* google_protobuf_EnumDescriptorProto_reserved_name(const google_protobuf_EnumDescriptorProto *msg, size_t *len) { return (upb_strview const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len); }
1954
2107
 
1955
2108
  UPB_INLINE void google_protobuf_EnumDescriptorProto_set_name(google_protobuf_EnumDescriptorProto *msg, upb_strview value) {
1956
2109
  _upb_sethas(msg, 1);
1957
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)) = value;
2110
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview) = value;
1958
2111
  }
1959
2112
  UPB_INLINE google_protobuf_EnumValueDescriptorProto** google_protobuf_EnumDescriptorProto_mutable_value(google_protobuf_EnumDescriptorProto *msg, size_t *len) {
1960
2113
  return (google_protobuf_EnumValueDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(16, 32), len);
1961
2114
  }
1962
2115
  UPB_INLINE google_protobuf_EnumValueDescriptorProto** google_protobuf_EnumDescriptorProto_resize_value(google_protobuf_EnumDescriptorProto *msg, size_t len, upb_arena *arena) {
1963
- return (google_protobuf_EnumValueDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(16, 32), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2116
+ return (google_protobuf_EnumValueDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(16, 32), len, UPB_TYPE_MESSAGE, arena);
1964
2117
  }
1965
2118
  UPB_INLINE struct google_protobuf_EnumValueDescriptorProto* google_protobuf_EnumDescriptorProto_add_value(google_protobuf_EnumDescriptorProto *msg, upb_arena *arena) {
1966
- struct google_protobuf_EnumValueDescriptorProto* sub = (struct google_protobuf_EnumValueDescriptorProto*)upb_msg_new(&google_protobuf_EnumValueDescriptorProto_msginit, arena);
2119
+ struct google_protobuf_EnumValueDescriptorProto* sub = (struct google_protobuf_EnumValueDescriptorProto*)_upb_msg_new(&google_protobuf_EnumValueDescriptorProto_msginit, arena);
1967
2120
  bool ok = _upb_array_append_accessor(
1968
2121
  msg, UPB_SIZE(16, 32), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1969
2122
  if (!ok) return NULL;
@@ -1971,12 +2124,12 @@ UPB_INLINE struct google_protobuf_EnumValueDescriptorProto* google_protobuf_Enum
1971
2124
  }
1972
2125
  UPB_INLINE void google_protobuf_EnumDescriptorProto_set_options(google_protobuf_EnumDescriptorProto *msg, google_protobuf_EnumOptions* value) {
1973
2126
  _upb_sethas(msg, 2);
1974
- UPB_FIELD_AT(msg, google_protobuf_EnumOptions*, UPB_SIZE(12, 24)) = value;
2127
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), google_protobuf_EnumOptions*) = value;
1975
2128
  }
1976
2129
  UPB_INLINE struct google_protobuf_EnumOptions* google_protobuf_EnumDescriptorProto_mutable_options(google_protobuf_EnumDescriptorProto *msg, upb_arena *arena) {
1977
2130
  struct google_protobuf_EnumOptions* sub = (struct google_protobuf_EnumOptions*)google_protobuf_EnumDescriptorProto_options(msg);
1978
2131
  if (sub == NULL) {
1979
- sub = (struct google_protobuf_EnumOptions*)upb_msg_new(&google_protobuf_EnumOptions_msginit, arena);
2132
+ sub = (struct google_protobuf_EnumOptions*)_upb_msg_new(&google_protobuf_EnumOptions_msginit, arena);
1980
2133
  if (!sub) return NULL;
1981
2134
  google_protobuf_EnumDescriptorProto_set_options(msg, sub);
1982
2135
  }
@@ -1986,10 +2139,10 @@ UPB_INLINE google_protobuf_EnumDescriptorProto_EnumReservedRange** google_protob
1986
2139
  return (google_protobuf_EnumDescriptorProto_EnumReservedRange**)_upb_array_mutable_accessor(msg, UPB_SIZE(20, 40), len);
1987
2140
  }
1988
2141
  UPB_INLINE google_protobuf_EnumDescriptorProto_EnumReservedRange** google_protobuf_EnumDescriptorProto_resize_reserved_range(google_protobuf_EnumDescriptorProto *msg, size_t len, upb_arena *arena) {
1989
- return (google_protobuf_EnumDescriptorProto_EnumReservedRange**)_upb_array_resize_accessor(msg, UPB_SIZE(20, 40), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2142
+ return (google_protobuf_EnumDescriptorProto_EnumReservedRange**)_upb_array_resize_accessor(msg, UPB_SIZE(20, 40), len, UPB_TYPE_MESSAGE, arena);
1990
2143
  }
1991
2144
  UPB_INLINE struct google_protobuf_EnumDescriptorProto_EnumReservedRange* google_protobuf_EnumDescriptorProto_add_reserved_range(google_protobuf_EnumDescriptorProto *msg, upb_arena *arena) {
1992
- struct google_protobuf_EnumDescriptorProto_EnumReservedRange* sub = (struct google_protobuf_EnumDescriptorProto_EnumReservedRange*)upb_msg_new(&google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit, arena);
2145
+ struct google_protobuf_EnumDescriptorProto_EnumReservedRange* sub = (struct google_protobuf_EnumDescriptorProto_EnumReservedRange*)_upb_msg_new(&google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit, arena);
1993
2146
  bool ok = _upb_array_append_accessor(
1994
2147
  msg, UPB_SIZE(20, 40), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
1995
2148
  if (!ok) return NULL;
@@ -1999,17 +2152,17 @@ UPB_INLINE upb_strview* google_protobuf_EnumDescriptorProto_mutable_reserved_nam
1999
2152
  return (upb_strview*)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 48), len);
2000
2153
  }
2001
2154
  UPB_INLINE upb_strview* google_protobuf_EnumDescriptorProto_resize_reserved_name(google_protobuf_EnumDescriptorProto *msg, size_t len, upb_arena *arena) {
2002
- return (upb_strview*)_upb_array_resize_accessor(msg, UPB_SIZE(24, 48), len, UPB_SIZE(8, 16), UPB_TYPE_STRING, arena);
2155
+ return (upb_strview*)_upb_array_resize_accessor(msg, UPB_SIZE(24, 48), len, UPB_TYPE_STRING, arena);
2003
2156
  }
2004
2157
  UPB_INLINE bool google_protobuf_EnumDescriptorProto_add_reserved_name(google_protobuf_EnumDescriptorProto *msg, upb_strview val, upb_arena *arena) {
2005
- return _upb_array_append_accessor(
2006
- msg, UPB_SIZE(24, 48), UPB_SIZE(8, 16), UPB_TYPE_STRING, &val, arena);
2158
+ return _upb_array_append_accessor(msg, UPB_SIZE(24, 48), UPB_SIZE(8, 16), UPB_TYPE_STRING, &val,
2159
+ arena);
2007
2160
  }
2008
2161
 
2009
2162
  /* google.protobuf.EnumDescriptorProto.EnumReservedRange */
2010
2163
 
2011
2164
  UPB_INLINE google_protobuf_EnumDescriptorProto_EnumReservedRange *google_protobuf_EnumDescriptorProto_EnumReservedRange_new(upb_arena *arena) {
2012
- return (google_protobuf_EnumDescriptorProto_EnumReservedRange *)upb_msg_new(&google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit, arena);
2165
+ return (google_protobuf_EnumDescriptorProto_EnumReservedRange *)_upb_msg_new(&google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit, arena);
2013
2166
  }
2014
2167
  UPB_INLINE google_protobuf_EnumDescriptorProto_EnumReservedRange *google_protobuf_EnumDescriptorProto_EnumReservedRange_parse(const char *buf, size_t size,
2015
2168
  upb_arena *arena) {
@@ -2021,23 +2174,23 @@ UPB_INLINE char *google_protobuf_EnumDescriptorProto_EnumReservedRange_serialize
2021
2174
  }
2022
2175
 
2023
2176
  UPB_INLINE bool google_protobuf_EnumDescriptorProto_EnumReservedRange_has_start(const google_protobuf_EnumDescriptorProto_EnumReservedRange *msg) { return _upb_has_field(msg, 1); }
2024
- UPB_INLINE int32_t google_protobuf_EnumDescriptorProto_EnumReservedRange_start(const google_protobuf_EnumDescriptorProto_EnumReservedRange *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(4, 4)); }
2177
+ UPB_INLINE int32_t google_protobuf_EnumDescriptorProto_EnumReservedRange_start(const google_protobuf_EnumDescriptorProto_EnumReservedRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t); }
2025
2178
  UPB_INLINE bool google_protobuf_EnumDescriptorProto_EnumReservedRange_has_end(const google_protobuf_EnumDescriptorProto_EnumReservedRange *msg) { return _upb_has_field(msg, 2); }
2026
- UPB_INLINE int32_t google_protobuf_EnumDescriptorProto_EnumReservedRange_end(const google_protobuf_EnumDescriptorProto_EnumReservedRange *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)); }
2179
+ UPB_INLINE int32_t google_protobuf_EnumDescriptorProto_EnumReservedRange_end(const google_protobuf_EnumDescriptorProto_EnumReservedRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
2027
2180
 
2028
2181
  UPB_INLINE void google_protobuf_EnumDescriptorProto_EnumReservedRange_set_start(google_protobuf_EnumDescriptorProto_EnumReservedRange *msg, int32_t value) {
2029
2182
  _upb_sethas(msg, 1);
2030
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(4, 4)) = value;
2183
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = value;
2031
2184
  }
2032
2185
  UPB_INLINE void google_protobuf_EnumDescriptorProto_EnumReservedRange_set_end(google_protobuf_EnumDescriptorProto_EnumReservedRange *msg, int32_t value) {
2033
2186
  _upb_sethas(msg, 2);
2034
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)) = value;
2187
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
2035
2188
  }
2036
2189
 
2037
2190
  /* google.protobuf.EnumValueDescriptorProto */
2038
2191
 
2039
2192
  UPB_INLINE google_protobuf_EnumValueDescriptorProto *google_protobuf_EnumValueDescriptorProto_new(upb_arena *arena) {
2040
- return (google_protobuf_EnumValueDescriptorProto *)upb_msg_new(&google_protobuf_EnumValueDescriptorProto_msginit, arena);
2193
+ return (google_protobuf_EnumValueDescriptorProto *)_upb_msg_new(&google_protobuf_EnumValueDescriptorProto_msginit, arena);
2041
2194
  }
2042
2195
  UPB_INLINE google_protobuf_EnumValueDescriptorProto *google_protobuf_EnumValueDescriptorProto_parse(const char *buf, size_t size,
2043
2196
  upb_arena *arena) {
@@ -2049,28 +2202,28 @@ UPB_INLINE char *google_protobuf_EnumValueDescriptorProto_serialize(const google
2049
2202
  }
2050
2203
 
2051
2204
  UPB_INLINE bool google_protobuf_EnumValueDescriptorProto_has_name(const google_protobuf_EnumValueDescriptorProto *msg) { return _upb_has_field(msg, 2); }
2052
- UPB_INLINE upb_strview google_protobuf_EnumValueDescriptorProto_name(const google_protobuf_EnumValueDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(8, 8)); }
2205
+ UPB_INLINE upb_strview google_protobuf_EnumValueDescriptorProto_name(const google_protobuf_EnumValueDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), upb_strview); }
2053
2206
  UPB_INLINE bool google_protobuf_EnumValueDescriptorProto_has_number(const google_protobuf_EnumValueDescriptorProto *msg) { return _upb_has_field(msg, 1); }
2054
- UPB_INLINE int32_t google_protobuf_EnumValueDescriptorProto_number(const google_protobuf_EnumValueDescriptorProto *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(4, 4)); }
2207
+ UPB_INLINE int32_t google_protobuf_EnumValueDescriptorProto_number(const google_protobuf_EnumValueDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t); }
2055
2208
  UPB_INLINE bool google_protobuf_EnumValueDescriptorProto_has_options(const google_protobuf_EnumValueDescriptorProto *msg) { return _upb_has_field(msg, 3); }
2056
- UPB_INLINE const google_protobuf_EnumValueOptions* google_protobuf_EnumValueDescriptorProto_options(const google_protobuf_EnumValueDescriptorProto *msg) { return UPB_FIELD_AT(msg, const google_protobuf_EnumValueOptions*, UPB_SIZE(16, 24)); }
2209
+ UPB_INLINE const google_protobuf_EnumValueOptions* google_protobuf_EnumValueDescriptorProto_options(const google_protobuf_EnumValueDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), const google_protobuf_EnumValueOptions*); }
2057
2210
 
2058
2211
  UPB_INLINE void google_protobuf_EnumValueDescriptorProto_set_name(google_protobuf_EnumValueDescriptorProto *msg, upb_strview value) {
2059
2212
  _upb_sethas(msg, 2);
2060
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(8, 8)) = value;
2213
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), upb_strview) = value;
2061
2214
  }
2062
2215
  UPB_INLINE void google_protobuf_EnumValueDescriptorProto_set_number(google_protobuf_EnumValueDescriptorProto *msg, int32_t value) {
2063
2216
  _upb_sethas(msg, 1);
2064
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(4, 4)) = value;
2217
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = value;
2065
2218
  }
2066
2219
  UPB_INLINE void google_protobuf_EnumValueDescriptorProto_set_options(google_protobuf_EnumValueDescriptorProto *msg, google_protobuf_EnumValueOptions* value) {
2067
2220
  _upb_sethas(msg, 3);
2068
- UPB_FIELD_AT(msg, google_protobuf_EnumValueOptions*, UPB_SIZE(16, 24)) = value;
2221
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 24), google_protobuf_EnumValueOptions*) = value;
2069
2222
  }
2070
2223
  UPB_INLINE struct google_protobuf_EnumValueOptions* google_protobuf_EnumValueDescriptorProto_mutable_options(google_protobuf_EnumValueDescriptorProto *msg, upb_arena *arena) {
2071
2224
  struct google_protobuf_EnumValueOptions* sub = (struct google_protobuf_EnumValueOptions*)google_protobuf_EnumValueDescriptorProto_options(msg);
2072
2225
  if (sub == NULL) {
2073
- sub = (struct google_protobuf_EnumValueOptions*)upb_msg_new(&google_protobuf_EnumValueOptions_msginit, arena);
2226
+ sub = (struct google_protobuf_EnumValueOptions*)_upb_msg_new(&google_protobuf_EnumValueOptions_msginit, arena);
2074
2227
  if (!sub) return NULL;
2075
2228
  google_protobuf_EnumValueDescriptorProto_set_options(msg, sub);
2076
2229
  }
@@ -2080,7 +2233,7 @@ UPB_INLINE struct google_protobuf_EnumValueOptions* google_protobuf_EnumValueDes
2080
2233
  /* google.protobuf.ServiceDescriptorProto */
2081
2234
 
2082
2235
  UPB_INLINE google_protobuf_ServiceDescriptorProto *google_protobuf_ServiceDescriptorProto_new(upb_arena *arena) {
2083
- return (google_protobuf_ServiceDescriptorProto *)upb_msg_new(&google_protobuf_ServiceDescriptorProto_msginit, arena);
2236
+ return (google_protobuf_ServiceDescriptorProto *)_upb_msg_new(&google_protobuf_ServiceDescriptorProto_msginit, arena);
2084
2237
  }
2085
2238
  UPB_INLINE google_protobuf_ServiceDescriptorProto *google_protobuf_ServiceDescriptorProto_parse(const char *buf, size_t size,
2086
2239
  upb_arena *arena) {
@@ -2092,23 +2245,24 @@ UPB_INLINE char *google_protobuf_ServiceDescriptorProto_serialize(const google_p
2092
2245
  }
2093
2246
 
2094
2247
  UPB_INLINE bool google_protobuf_ServiceDescriptorProto_has_name(const google_protobuf_ServiceDescriptorProto *msg) { return _upb_has_field(msg, 1); }
2095
- UPB_INLINE upb_strview google_protobuf_ServiceDescriptorProto_name(const google_protobuf_ServiceDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)); }
2248
+ UPB_INLINE upb_strview google_protobuf_ServiceDescriptorProto_name(const google_protobuf_ServiceDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
2249
+ UPB_INLINE bool google_protobuf_ServiceDescriptorProto_has_method(const google_protobuf_ServiceDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(16, 32)); }
2096
2250
  UPB_INLINE const google_protobuf_MethodDescriptorProto* const* google_protobuf_ServiceDescriptorProto_method(const google_protobuf_ServiceDescriptorProto *msg, size_t *len) { return (const google_protobuf_MethodDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(16, 32), len); }
2097
2251
  UPB_INLINE bool google_protobuf_ServiceDescriptorProto_has_options(const google_protobuf_ServiceDescriptorProto *msg) { return _upb_has_field(msg, 2); }
2098
- UPB_INLINE const google_protobuf_ServiceOptions* google_protobuf_ServiceDescriptorProto_options(const google_protobuf_ServiceDescriptorProto *msg) { return UPB_FIELD_AT(msg, const google_protobuf_ServiceOptions*, UPB_SIZE(12, 24)); }
2252
+ UPB_INLINE const google_protobuf_ServiceOptions* google_protobuf_ServiceDescriptorProto_options(const google_protobuf_ServiceDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_ServiceOptions*); }
2099
2253
 
2100
2254
  UPB_INLINE void google_protobuf_ServiceDescriptorProto_set_name(google_protobuf_ServiceDescriptorProto *msg, upb_strview value) {
2101
2255
  _upb_sethas(msg, 1);
2102
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)) = value;
2256
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview) = value;
2103
2257
  }
2104
2258
  UPB_INLINE google_protobuf_MethodDescriptorProto** google_protobuf_ServiceDescriptorProto_mutable_method(google_protobuf_ServiceDescriptorProto *msg, size_t *len) {
2105
2259
  return (google_protobuf_MethodDescriptorProto**)_upb_array_mutable_accessor(msg, UPB_SIZE(16, 32), len);
2106
2260
  }
2107
2261
  UPB_INLINE google_protobuf_MethodDescriptorProto** google_protobuf_ServiceDescriptorProto_resize_method(google_protobuf_ServiceDescriptorProto *msg, size_t len, upb_arena *arena) {
2108
- return (google_protobuf_MethodDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(16, 32), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2262
+ return (google_protobuf_MethodDescriptorProto**)_upb_array_resize_accessor(msg, UPB_SIZE(16, 32), len, UPB_TYPE_MESSAGE, arena);
2109
2263
  }
2110
2264
  UPB_INLINE struct google_protobuf_MethodDescriptorProto* google_protobuf_ServiceDescriptorProto_add_method(google_protobuf_ServiceDescriptorProto *msg, upb_arena *arena) {
2111
- struct google_protobuf_MethodDescriptorProto* sub = (struct google_protobuf_MethodDescriptorProto*)upb_msg_new(&google_protobuf_MethodDescriptorProto_msginit, arena);
2265
+ struct google_protobuf_MethodDescriptorProto* sub = (struct google_protobuf_MethodDescriptorProto*)_upb_msg_new(&google_protobuf_MethodDescriptorProto_msginit, arena);
2112
2266
  bool ok = _upb_array_append_accessor(
2113
2267
  msg, UPB_SIZE(16, 32), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2114
2268
  if (!ok) return NULL;
@@ -2116,12 +2270,12 @@ UPB_INLINE struct google_protobuf_MethodDescriptorProto* google_protobuf_Service
2116
2270
  }
2117
2271
  UPB_INLINE void google_protobuf_ServiceDescriptorProto_set_options(google_protobuf_ServiceDescriptorProto *msg, google_protobuf_ServiceOptions* value) {
2118
2272
  _upb_sethas(msg, 2);
2119
- UPB_FIELD_AT(msg, google_protobuf_ServiceOptions*, UPB_SIZE(12, 24)) = value;
2273
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), google_protobuf_ServiceOptions*) = value;
2120
2274
  }
2121
2275
  UPB_INLINE struct google_protobuf_ServiceOptions* google_protobuf_ServiceDescriptorProto_mutable_options(google_protobuf_ServiceDescriptorProto *msg, upb_arena *arena) {
2122
2276
  struct google_protobuf_ServiceOptions* sub = (struct google_protobuf_ServiceOptions*)google_protobuf_ServiceDescriptorProto_options(msg);
2123
2277
  if (sub == NULL) {
2124
- sub = (struct google_protobuf_ServiceOptions*)upb_msg_new(&google_protobuf_ServiceOptions_msginit, arena);
2278
+ sub = (struct google_protobuf_ServiceOptions*)_upb_msg_new(&google_protobuf_ServiceOptions_msginit, arena);
2125
2279
  if (!sub) return NULL;
2126
2280
  google_protobuf_ServiceDescriptorProto_set_options(msg, sub);
2127
2281
  }
@@ -2131,7 +2285,7 @@ UPB_INLINE struct google_protobuf_ServiceOptions* google_protobuf_ServiceDescrip
2131
2285
  /* google.protobuf.MethodDescriptorProto */
2132
2286
 
2133
2287
  UPB_INLINE google_protobuf_MethodDescriptorProto *google_protobuf_MethodDescriptorProto_new(upb_arena *arena) {
2134
- return (google_protobuf_MethodDescriptorProto *)upb_msg_new(&google_protobuf_MethodDescriptorProto_msginit, arena);
2288
+ return (google_protobuf_MethodDescriptorProto *)_upb_msg_new(&google_protobuf_MethodDescriptorProto_msginit, arena);
2135
2289
  }
2136
2290
  UPB_INLINE google_protobuf_MethodDescriptorProto *google_protobuf_MethodDescriptorProto_parse(const char *buf, size_t size,
2137
2291
  upb_arena *arena) {
@@ -2143,38 +2297,38 @@ UPB_INLINE char *google_protobuf_MethodDescriptorProto_serialize(const google_pr
2143
2297
  }
2144
2298
 
2145
2299
  UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_name(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 3); }
2146
- UPB_INLINE upb_strview google_protobuf_MethodDescriptorProto_name(const google_protobuf_MethodDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)); }
2300
+ UPB_INLINE upb_strview google_protobuf_MethodDescriptorProto_name(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
2147
2301
  UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_input_type(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 4); }
2148
- UPB_INLINE upb_strview google_protobuf_MethodDescriptorProto_input_type(const google_protobuf_MethodDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(12, 24)); }
2302
+ UPB_INLINE upb_strview google_protobuf_MethodDescriptorProto_input_type(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_strview); }
2149
2303
  UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_output_type(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 5); }
2150
- UPB_INLINE upb_strview google_protobuf_MethodDescriptorProto_output_type(const google_protobuf_MethodDescriptorProto *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(20, 40)); }
2304
+ UPB_INLINE upb_strview google_protobuf_MethodDescriptorProto_output_type(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_strview); }
2151
2305
  UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_options(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 6); }
2152
- UPB_INLINE const google_protobuf_MethodOptions* google_protobuf_MethodDescriptorProto_options(const google_protobuf_MethodDescriptorProto *msg) { return UPB_FIELD_AT(msg, const google_protobuf_MethodOptions*, UPB_SIZE(28, 56)); }
2306
+ UPB_INLINE const google_protobuf_MethodOptions* google_protobuf_MethodDescriptorProto_options(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(28, 56), const google_protobuf_MethodOptions*); }
2153
2307
  UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_client_streaming(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 1); }
2154
- UPB_INLINE bool google_protobuf_MethodDescriptorProto_client_streaming(const google_protobuf_MethodDescriptorProto *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)); }
2308
+ UPB_INLINE bool google_protobuf_MethodDescriptorProto_client_streaming(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2155
2309
  UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_server_streaming(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 2); }
2156
- UPB_INLINE bool google_protobuf_MethodDescriptorProto_server_streaming(const google_protobuf_MethodDescriptorProto *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(2, 2)); }
2310
+ UPB_INLINE bool google_protobuf_MethodDescriptorProto_server_streaming(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool); }
2157
2311
 
2158
2312
  UPB_INLINE void google_protobuf_MethodDescriptorProto_set_name(google_protobuf_MethodDescriptorProto *msg, upb_strview value) {
2159
2313
  _upb_sethas(msg, 3);
2160
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)) = value;
2314
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview) = value;
2161
2315
  }
2162
2316
  UPB_INLINE void google_protobuf_MethodDescriptorProto_set_input_type(google_protobuf_MethodDescriptorProto *msg, upb_strview value) {
2163
2317
  _upb_sethas(msg, 4);
2164
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(12, 24)) = value;
2318
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_strview) = value;
2165
2319
  }
2166
2320
  UPB_INLINE void google_protobuf_MethodDescriptorProto_set_output_type(google_protobuf_MethodDescriptorProto *msg, upb_strview value) {
2167
2321
  _upb_sethas(msg, 5);
2168
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(20, 40)) = value;
2322
+ *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_strview) = value;
2169
2323
  }
2170
2324
  UPB_INLINE void google_protobuf_MethodDescriptorProto_set_options(google_protobuf_MethodDescriptorProto *msg, google_protobuf_MethodOptions* value) {
2171
2325
  _upb_sethas(msg, 6);
2172
- UPB_FIELD_AT(msg, google_protobuf_MethodOptions*, UPB_SIZE(28, 56)) = value;
2326
+ *UPB_PTR_AT(msg, UPB_SIZE(28, 56), google_protobuf_MethodOptions*) = value;
2173
2327
  }
2174
2328
  UPB_INLINE struct google_protobuf_MethodOptions* google_protobuf_MethodDescriptorProto_mutable_options(google_protobuf_MethodDescriptorProto *msg, upb_arena *arena) {
2175
2329
  struct google_protobuf_MethodOptions* sub = (struct google_protobuf_MethodOptions*)google_protobuf_MethodDescriptorProto_options(msg);
2176
2330
  if (sub == NULL) {
2177
- sub = (struct google_protobuf_MethodOptions*)upb_msg_new(&google_protobuf_MethodOptions_msginit, arena);
2331
+ sub = (struct google_protobuf_MethodOptions*)_upb_msg_new(&google_protobuf_MethodOptions_msginit, arena);
2178
2332
  if (!sub) return NULL;
2179
2333
  google_protobuf_MethodDescriptorProto_set_options(msg, sub);
2180
2334
  }
@@ -2182,17 +2336,17 @@ UPB_INLINE struct google_protobuf_MethodOptions* google_protobuf_MethodDescripto
2182
2336
  }
2183
2337
  UPB_INLINE void google_protobuf_MethodDescriptorProto_set_client_streaming(google_protobuf_MethodDescriptorProto *msg, bool value) {
2184
2338
  _upb_sethas(msg, 1);
2185
- UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)) = value;
2339
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
2186
2340
  }
2187
2341
  UPB_INLINE void google_protobuf_MethodDescriptorProto_set_server_streaming(google_protobuf_MethodDescriptorProto *msg, bool value) {
2188
2342
  _upb_sethas(msg, 2);
2189
- UPB_FIELD_AT(msg, bool, UPB_SIZE(2, 2)) = value;
2343
+ *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = value;
2190
2344
  }
2191
2345
 
2192
2346
  /* google.protobuf.FileOptions */
2193
2347
 
2194
2348
  UPB_INLINE google_protobuf_FileOptions *google_protobuf_FileOptions_new(upb_arena *arena) {
2195
- return (google_protobuf_FileOptions *)upb_msg_new(&google_protobuf_FileOptions_msginit, arena);
2349
+ return (google_protobuf_FileOptions *)_upb_msg_new(&google_protobuf_FileOptions_msginit, arena);
2196
2350
  }
2197
2351
  UPB_INLINE google_protobuf_FileOptions *google_protobuf_FileOptions_parse(const char *buf, size_t size,
2198
2352
  upb_arena *arena) {
@@ -2204,135 +2358,136 @@ UPB_INLINE char *google_protobuf_FileOptions_serialize(const google_protobuf_Fil
2204
2358
  }
2205
2359
 
2206
2360
  UPB_INLINE bool google_protobuf_FileOptions_has_java_package(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 11); }
2207
- UPB_INLINE upb_strview google_protobuf_FileOptions_java_package(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(28, 32)); }
2361
+ UPB_INLINE upb_strview google_protobuf_FileOptions_java_package(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(28, 32), upb_strview); }
2208
2362
  UPB_INLINE bool google_protobuf_FileOptions_has_java_outer_classname(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 12); }
2209
- UPB_INLINE upb_strview google_protobuf_FileOptions_java_outer_classname(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(36, 48)); }
2363
+ UPB_INLINE upb_strview google_protobuf_FileOptions_java_outer_classname(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(36, 48), upb_strview); }
2210
2364
  UPB_INLINE bool google_protobuf_FileOptions_has_optimize_for(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 1); }
2211
- UPB_INLINE int32_t google_protobuf_FileOptions_optimize_for(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)); }
2365
+ UPB_INLINE int32_t google_protobuf_FileOptions_optimize_for(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
2212
2366
  UPB_INLINE bool google_protobuf_FileOptions_has_java_multiple_files(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 2); }
2213
- UPB_INLINE bool google_protobuf_FileOptions_java_multiple_files(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(16, 16)); }
2367
+ UPB_INLINE bool google_protobuf_FileOptions_java_multiple_files(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool); }
2214
2368
  UPB_INLINE bool google_protobuf_FileOptions_has_go_package(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 13); }
2215
- UPB_INLINE upb_strview google_protobuf_FileOptions_go_package(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(44, 64)); }
2369
+ UPB_INLINE upb_strview google_protobuf_FileOptions_go_package(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(44, 64), upb_strview); }
2216
2370
  UPB_INLINE bool google_protobuf_FileOptions_has_cc_generic_services(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 3); }
2217
- UPB_INLINE bool google_protobuf_FileOptions_cc_generic_services(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(17, 17)); }
2371
+ UPB_INLINE bool google_protobuf_FileOptions_cc_generic_services(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(17, 17), bool); }
2218
2372
  UPB_INLINE bool google_protobuf_FileOptions_has_java_generic_services(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 4); }
2219
- UPB_INLINE bool google_protobuf_FileOptions_java_generic_services(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(18, 18)); }
2373
+ UPB_INLINE bool google_protobuf_FileOptions_java_generic_services(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(18, 18), bool); }
2220
2374
  UPB_INLINE bool google_protobuf_FileOptions_has_py_generic_services(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 5); }
2221
- UPB_INLINE bool google_protobuf_FileOptions_py_generic_services(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(19, 19)); }
2375
+ UPB_INLINE bool google_protobuf_FileOptions_py_generic_services(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(19, 19), bool); }
2222
2376
  UPB_INLINE bool google_protobuf_FileOptions_has_java_generate_equals_and_hash(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 6); }
2223
- UPB_INLINE bool google_protobuf_FileOptions_java_generate_equals_and_hash(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(20, 20)); }
2377
+ UPB_INLINE bool google_protobuf_FileOptions_java_generate_equals_and_hash(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(20, 20), bool); }
2224
2378
  UPB_INLINE bool google_protobuf_FileOptions_has_deprecated(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 7); }
2225
- UPB_INLINE bool google_protobuf_FileOptions_deprecated(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(21, 21)); }
2379
+ UPB_INLINE bool google_protobuf_FileOptions_deprecated(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(21, 21), bool); }
2226
2380
  UPB_INLINE bool google_protobuf_FileOptions_has_java_string_check_utf8(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 8); }
2227
- UPB_INLINE bool google_protobuf_FileOptions_java_string_check_utf8(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(22, 22)); }
2381
+ UPB_INLINE bool google_protobuf_FileOptions_java_string_check_utf8(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(22, 22), bool); }
2228
2382
  UPB_INLINE bool google_protobuf_FileOptions_has_cc_enable_arenas(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 9); }
2229
- UPB_INLINE bool google_protobuf_FileOptions_cc_enable_arenas(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(23, 23)); }
2383
+ UPB_INLINE bool google_protobuf_FileOptions_cc_enable_arenas(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(23, 23), bool); }
2230
2384
  UPB_INLINE bool google_protobuf_FileOptions_has_objc_class_prefix(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 14); }
2231
- UPB_INLINE upb_strview google_protobuf_FileOptions_objc_class_prefix(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(52, 80)); }
2385
+ UPB_INLINE upb_strview google_protobuf_FileOptions_objc_class_prefix(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(52, 80), upb_strview); }
2232
2386
  UPB_INLINE bool google_protobuf_FileOptions_has_csharp_namespace(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 15); }
2233
- UPB_INLINE upb_strview google_protobuf_FileOptions_csharp_namespace(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(60, 96)); }
2387
+ UPB_INLINE upb_strview google_protobuf_FileOptions_csharp_namespace(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(60, 96), upb_strview); }
2234
2388
  UPB_INLINE bool google_protobuf_FileOptions_has_swift_prefix(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 16); }
2235
- UPB_INLINE upb_strview google_protobuf_FileOptions_swift_prefix(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(68, 112)); }
2389
+ UPB_INLINE upb_strview google_protobuf_FileOptions_swift_prefix(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(68, 112), upb_strview); }
2236
2390
  UPB_INLINE bool google_protobuf_FileOptions_has_php_class_prefix(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 17); }
2237
- UPB_INLINE upb_strview google_protobuf_FileOptions_php_class_prefix(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(76, 128)); }
2391
+ UPB_INLINE upb_strview google_protobuf_FileOptions_php_class_prefix(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(76, 128), upb_strview); }
2238
2392
  UPB_INLINE bool google_protobuf_FileOptions_has_php_namespace(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 18); }
2239
- UPB_INLINE upb_strview google_protobuf_FileOptions_php_namespace(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(84, 144)); }
2393
+ UPB_INLINE upb_strview google_protobuf_FileOptions_php_namespace(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(84, 144), upb_strview); }
2240
2394
  UPB_INLINE bool google_protobuf_FileOptions_has_php_generic_services(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 10); }
2241
- UPB_INLINE bool google_protobuf_FileOptions_php_generic_services(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(24, 24)); }
2395
+ UPB_INLINE bool google_protobuf_FileOptions_php_generic_services(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool); }
2242
2396
  UPB_INLINE bool google_protobuf_FileOptions_has_php_metadata_namespace(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 19); }
2243
- UPB_INLINE upb_strview google_protobuf_FileOptions_php_metadata_namespace(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(92, 160)); }
2397
+ UPB_INLINE upb_strview google_protobuf_FileOptions_php_metadata_namespace(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(92, 160), upb_strview); }
2244
2398
  UPB_INLINE bool google_protobuf_FileOptions_has_ruby_package(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 20); }
2245
- UPB_INLINE upb_strview google_protobuf_FileOptions_ruby_package(const google_protobuf_FileOptions *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(100, 176)); }
2399
+ UPB_INLINE upb_strview google_protobuf_FileOptions_ruby_package(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(100, 176), upb_strview); }
2400
+ UPB_INLINE bool google_protobuf_FileOptions_has_uninterpreted_option(const google_protobuf_FileOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(108, 192)); }
2246
2401
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_FileOptions_uninterpreted_option(const google_protobuf_FileOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(108, 192), len); }
2247
2402
 
2248
2403
  UPB_INLINE void google_protobuf_FileOptions_set_java_package(google_protobuf_FileOptions *msg, upb_strview value) {
2249
2404
  _upb_sethas(msg, 11);
2250
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(28, 32)) = value;
2405
+ *UPB_PTR_AT(msg, UPB_SIZE(28, 32), upb_strview) = value;
2251
2406
  }
2252
2407
  UPB_INLINE void google_protobuf_FileOptions_set_java_outer_classname(google_protobuf_FileOptions *msg, upb_strview value) {
2253
2408
  _upb_sethas(msg, 12);
2254
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(36, 48)) = value;
2409
+ *UPB_PTR_AT(msg, UPB_SIZE(36, 48), upb_strview) = value;
2255
2410
  }
2256
2411
  UPB_INLINE void google_protobuf_FileOptions_set_optimize_for(google_protobuf_FileOptions *msg, int32_t value) {
2257
2412
  _upb_sethas(msg, 1);
2258
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)) = value;
2413
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
2259
2414
  }
2260
2415
  UPB_INLINE void google_protobuf_FileOptions_set_java_multiple_files(google_protobuf_FileOptions *msg, bool value) {
2261
2416
  _upb_sethas(msg, 2);
2262
- UPB_FIELD_AT(msg, bool, UPB_SIZE(16, 16)) = value;
2417
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool) = value;
2263
2418
  }
2264
2419
  UPB_INLINE void google_protobuf_FileOptions_set_go_package(google_protobuf_FileOptions *msg, upb_strview value) {
2265
2420
  _upb_sethas(msg, 13);
2266
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(44, 64)) = value;
2421
+ *UPB_PTR_AT(msg, UPB_SIZE(44, 64), upb_strview) = value;
2267
2422
  }
2268
2423
  UPB_INLINE void google_protobuf_FileOptions_set_cc_generic_services(google_protobuf_FileOptions *msg, bool value) {
2269
2424
  _upb_sethas(msg, 3);
2270
- UPB_FIELD_AT(msg, bool, UPB_SIZE(17, 17)) = value;
2425
+ *UPB_PTR_AT(msg, UPB_SIZE(17, 17), bool) = value;
2271
2426
  }
2272
2427
  UPB_INLINE void google_protobuf_FileOptions_set_java_generic_services(google_protobuf_FileOptions *msg, bool value) {
2273
2428
  _upb_sethas(msg, 4);
2274
- UPB_FIELD_AT(msg, bool, UPB_SIZE(18, 18)) = value;
2429
+ *UPB_PTR_AT(msg, UPB_SIZE(18, 18), bool) = value;
2275
2430
  }
2276
2431
  UPB_INLINE void google_protobuf_FileOptions_set_py_generic_services(google_protobuf_FileOptions *msg, bool value) {
2277
2432
  _upb_sethas(msg, 5);
2278
- UPB_FIELD_AT(msg, bool, UPB_SIZE(19, 19)) = value;
2433
+ *UPB_PTR_AT(msg, UPB_SIZE(19, 19), bool) = value;
2279
2434
  }
2280
2435
  UPB_INLINE void google_protobuf_FileOptions_set_java_generate_equals_and_hash(google_protobuf_FileOptions *msg, bool value) {
2281
2436
  _upb_sethas(msg, 6);
2282
- UPB_FIELD_AT(msg, bool, UPB_SIZE(20, 20)) = value;
2437
+ *UPB_PTR_AT(msg, UPB_SIZE(20, 20), bool) = value;
2283
2438
  }
2284
2439
  UPB_INLINE void google_protobuf_FileOptions_set_deprecated(google_protobuf_FileOptions *msg, bool value) {
2285
2440
  _upb_sethas(msg, 7);
2286
- UPB_FIELD_AT(msg, bool, UPB_SIZE(21, 21)) = value;
2441
+ *UPB_PTR_AT(msg, UPB_SIZE(21, 21), bool) = value;
2287
2442
  }
2288
2443
  UPB_INLINE void google_protobuf_FileOptions_set_java_string_check_utf8(google_protobuf_FileOptions *msg, bool value) {
2289
2444
  _upb_sethas(msg, 8);
2290
- UPB_FIELD_AT(msg, bool, UPB_SIZE(22, 22)) = value;
2445
+ *UPB_PTR_AT(msg, UPB_SIZE(22, 22), bool) = value;
2291
2446
  }
2292
2447
  UPB_INLINE void google_protobuf_FileOptions_set_cc_enable_arenas(google_protobuf_FileOptions *msg, bool value) {
2293
2448
  _upb_sethas(msg, 9);
2294
- UPB_FIELD_AT(msg, bool, UPB_SIZE(23, 23)) = value;
2449
+ *UPB_PTR_AT(msg, UPB_SIZE(23, 23), bool) = value;
2295
2450
  }
2296
2451
  UPB_INLINE void google_protobuf_FileOptions_set_objc_class_prefix(google_protobuf_FileOptions *msg, upb_strview value) {
2297
2452
  _upb_sethas(msg, 14);
2298
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(52, 80)) = value;
2453
+ *UPB_PTR_AT(msg, UPB_SIZE(52, 80), upb_strview) = value;
2299
2454
  }
2300
2455
  UPB_INLINE void google_protobuf_FileOptions_set_csharp_namespace(google_protobuf_FileOptions *msg, upb_strview value) {
2301
2456
  _upb_sethas(msg, 15);
2302
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(60, 96)) = value;
2457
+ *UPB_PTR_AT(msg, UPB_SIZE(60, 96), upb_strview) = value;
2303
2458
  }
2304
2459
  UPB_INLINE void google_protobuf_FileOptions_set_swift_prefix(google_protobuf_FileOptions *msg, upb_strview value) {
2305
2460
  _upb_sethas(msg, 16);
2306
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(68, 112)) = value;
2461
+ *UPB_PTR_AT(msg, UPB_SIZE(68, 112), upb_strview) = value;
2307
2462
  }
2308
2463
  UPB_INLINE void google_protobuf_FileOptions_set_php_class_prefix(google_protobuf_FileOptions *msg, upb_strview value) {
2309
2464
  _upb_sethas(msg, 17);
2310
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(76, 128)) = value;
2465
+ *UPB_PTR_AT(msg, UPB_SIZE(76, 128), upb_strview) = value;
2311
2466
  }
2312
2467
  UPB_INLINE void google_protobuf_FileOptions_set_php_namespace(google_protobuf_FileOptions *msg, upb_strview value) {
2313
2468
  _upb_sethas(msg, 18);
2314
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(84, 144)) = value;
2469
+ *UPB_PTR_AT(msg, UPB_SIZE(84, 144), upb_strview) = value;
2315
2470
  }
2316
2471
  UPB_INLINE void google_protobuf_FileOptions_set_php_generic_services(google_protobuf_FileOptions *msg, bool value) {
2317
2472
  _upb_sethas(msg, 10);
2318
- UPB_FIELD_AT(msg, bool, UPB_SIZE(24, 24)) = value;
2473
+ *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = value;
2319
2474
  }
2320
2475
  UPB_INLINE void google_protobuf_FileOptions_set_php_metadata_namespace(google_protobuf_FileOptions *msg, upb_strview value) {
2321
2476
  _upb_sethas(msg, 19);
2322
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(92, 160)) = value;
2477
+ *UPB_PTR_AT(msg, UPB_SIZE(92, 160), upb_strview) = value;
2323
2478
  }
2324
2479
  UPB_INLINE void google_protobuf_FileOptions_set_ruby_package(google_protobuf_FileOptions *msg, upb_strview value) {
2325
2480
  _upb_sethas(msg, 20);
2326
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(100, 176)) = value;
2481
+ *UPB_PTR_AT(msg, UPB_SIZE(100, 176), upb_strview) = value;
2327
2482
  }
2328
2483
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_FileOptions_mutable_uninterpreted_option(google_protobuf_FileOptions *msg, size_t *len) {
2329
2484
  return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(108, 192), len);
2330
2485
  }
2331
2486
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_FileOptions_resize_uninterpreted_option(google_protobuf_FileOptions *msg, size_t len, upb_arena *arena) {
2332
- return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(108, 192), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2487
+ return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(108, 192), len, UPB_TYPE_MESSAGE, arena);
2333
2488
  }
2334
2489
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_FileOptions_add_uninterpreted_option(google_protobuf_FileOptions *msg, upb_arena *arena) {
2335
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2490
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2336
2491
  bool ok = _upb_array_append_accessor(
2337
2492
  msg, UPB_SIZE(108, 192), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2338
2493
  if (!ok) return NULL;
@@ -2342,7 +2497,7 @@ UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_FileOptio
2342
2497
  /* google.protobuf.MessageOptions */
2343
2498
 
2344
2499
  UPB_INLINE google_protobuf_MessageOptions *google_protobuf_MessageOptions_new(upb_arena *arena) {
2345
- return (google_protobuf_MessageOptions *)upb_msg_new(&google_protobuf_MessageOptions_msginit, arena);
2500
+ return (google_protobuf_MessageOptions *)_upb_msg_new(&google_protobuf_MessageOptions_msginit, arena);
2346
2501
  }
2347
2502
  UPB_INLINE google_protobuf_MessageOptions *google_protobuf_MessageOptions_parse(const char *buf, size_t size,
2348
2503
  upb_arena *arena) {
@@ -2354,39 +2509,40 @@ UPB_INLINE char *google_protobuf_MessageOptions_serialize(const google_protobuf_
2354
2509
  }
2355
2510
 
2356
2511
  UPB_INLINE bool google_protobuf_MessageOptions_has_message_set_wire_format(const google_protobuf_MessageOptions *msg) { return _upb_has_field(msg, 1); }
2357
- UPB_INLINE bool google_protobuf_MessageOptions_message_set_wire_format(const google_protobuf_MessageOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)); }
2512
+ UPB_INLINE bool google_protobuf_MessageOptions_message_set_wire_format(const google_protobuf_MessageOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2358
2513
  UPB_INLINE bool google_protobuf_MessageOptions_has_no_standard_descriptor_accessor(const google_protobuf_MessageOptions *msg) { return _upb_has_field(msg, 2); }
2359
- UPB_INLINE bool google_protobuf_MessageOptions_no_standard_descriptor_accessor(const google_protobuf_MessageOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(2, 2)); }
2514
+ UPB_INLINE bool google_protobuf_MessageOptions_no_standard_descriptor_accessor(const google_protobuf_MessageOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool); }
2360
2515
  UPB_INLINE bool google_protobuf_MessageOptions_has_deprecated(const google_protobuf_MessageOptions *msg) { return _upb_has_field(msg, 3); }
2361
- UPB_INLINE bool google_protobuf_MessageOptions_deprecated(const google_protobuf_MessageOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(3, 3)); }
2516
+ UPB_INLINE bool google_protobuf_MessageOptions_deprecated(const google_protobuf_MessageOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(3, 3), bool); }
2362
2517
  UPB_INLINE bool google_protobuf_MessageOptions_has_map_entry(const google_protobuf_MessageOptions *msg) { return _upb_has_field(msg, 4); }
2363
- UPB_INLINE bool google_protobuf_MessageOptions_map_entry(const google_protobuf_MessageOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(4, 4)); }
2518
+ UPB_INLINE bool google_protobuf_MessageOptions_map_entry(const google_protobuf_MessageOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), bool); }
2519
+ UPB_INLINE bool google_protobuf_MessageOptions_has_uninterpreted_option(const google_protobuf_MessageOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(8, 8)); }
2364
2520
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_MessageOptions_uninterpreted_option(const google_protobuf_MessageOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(8, 8), len); }
2365
2521
 
2366
2522
  UPB_INLINE void google_protobuf_MessageOptions_set_message_set_wire_format(google_protobuf_MessageOptions *msg, bool value) {
2367
2523
  _upb_sethas(msg, 1);
2368
- UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)) = value;
2524
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
2369
2525
  }
2370
2526
  UPB_INLINE void google_protobuf_MessageOptions_set_no_standard_descriptor_accessor(google_protobuf_MessageOptions *msg, bool value) {
2371
2527
  _upb_sethas(msg, 2);
2372
- UPB_FIELD_AT(msg, bool, UPB_SIZE(2, 2)) = value;
2528
+ *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = value;
2373
2529
  }
2374
2530
  UPB_INLINE void google_protobuf_MessageOptions_set_deprecated(google_protobuf_MessageOptions *msg, bool value) {
2375
2531
  _upb_sethas(msg, 3);
2376
- UPB_FIELD_AT(msg, bool, UPB_SIZE(3, 3)) = value;
2532
+ *UPB_PTR_AT(msg, UPB_SIZE(3, 3), bool) = value;
2377
2533
  }
2378
2534
  UPB_INLINE void google_protobuf_MessageOptions_set_map_entry(google_protobuf_MessageOptions *msg, bool value) {
2379
2535
  _upb_sethas(msg, 4);
2380
- UPB_FIELD_AT(msg, bool, UPB_SIZE(4, 4)) = value;
2536
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), bool) = value;
2381
2537
  }
2382
2538
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_MessageOptions_mutable_uninterpreted_option(google_protobuf_MessageOptions *msg, size_t *len) {
2383
2539
  return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(8, 8), len);
2384
2540
  }
2385
2541
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_MessageOptions_resize_uninterpreted_option(google_protobuf_MessageOptions *msg, size_t len, upb_arena *arena) {
2386
- return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(8, 8), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2542
+ return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(8, 8), len, UPB_TYPE_MESSAGE, arena);
2387
2543
  }
2388
2544
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_MessageOptions_add_uninterpreted_option(google_protobuf_MessageOptions *msg, upb_arena *arena) {
2389
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2545
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2390
2546
  bool ok = _upb_array_append_accessor(
2391
2547
  msg, UPB_SIZE(8, 8), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2392
2548
  if (!ok) return NULL;
@@ -2396,7 +2552,7 @@ UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_MessageOp
2396
2552
  /* google.protobuf.FieldOptions */
2397
2553
 
2398
2554
  UPB_INLINE google_protobuf_FieldOptions *google_protobuf_FieldOptions_new(upb_arena *arena) {
2399
- return (google_protobuf_FieldOptions *)upb_msg_new(&google_protobuf_FieldOptions_msginit, arena);
2555
+ return (google_protobuf_FieldOptions *)_upb_msg_new(&google_protobuf_FieldOptions_msginit, arena);
2400
2556
  }
2401
2557
  UPB_INLINE google_protobuf_FieldOptions *google_protobuf_FieldOptions_parse(const char *buf, size_t size,
2402
2558
  upb_arena *arena) {
@@ -2408,51 +2564,52 @@ UPB_INLINE char *google_protobuf_FieldOptions_serialize(const google_protobuf_Fi
2408
2564
  }
2409
2565
 
2410
2566
  UPB_INLINE bool google_protobuf_FieldOptions_has_ctype(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 1); }
2411
- UPB_INLINE int32_t google_protobuf_FieldOptions_ctype(const google_protobuf_FieldOptions *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)); }
2567
+ UPB_INLINE int32_t google_protobuf_FieldOptions_ctype(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
2412
2568
  UPB_INLINE bool google_protobuf_FieldOptions_has_packed(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 3); }
2413
- UPB_INLINE bool google_protobuf_FieldOptions_packed(const google_protobuf_FieldOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(24, 24)); }
2569
+ UPB_INLINE bool google_protobuf_FieldOptions_packed(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool); }
2414
2570
  UPB_INLINE bool google_protobuf_FieldOptions_has_deprecated(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 4); }
2415
- UPB_INLINE bool google_protobuf_FieldOptions_deprecated(const google_protobuf_FieldOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(25, 25)); }
2571
+ UPB_INLINE bool google_protobuf_FieldOptions_deprecated(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(25, 25), bool); }
2416
2572
  UPB_INLINE bool google_protobuf_FieldOptions_has_lazy(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 5); }
2417
- UPB_INLINE bool google_protobuf_FieldOptions_lazy(const google_protobuf_FieldOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(26, 26)); }
2573
+ UPB_INLINE bool google_protobuf_FieldOptions_lazy(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(26, 26), bool); }
2418
2574
  UPB_INLINE bool google_protobuf_FieldOptions_has_jstype(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 2); }
2419
- UPB_INLINE int32_t google_protobuf_FieldOptions_jstype(const google_protobuf_FieldOptions *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(16, 16)); }
2575
+ UPB_INLINE int32_t google_protobuf_FieldOptions_jstype(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t); }
2420
2576
  UPB_INLINE bool google_protobuf_FieldOptions_has_weak(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 6); }
2421
- UPB_INLINE bool google_protobuf_FieldOptions_weak(const google_protobuf_FieldOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(27, 27)); }
2577
+ UPB_INLINE bool google_protobuf_FieldOptions_weak(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(27, 27), bool); }
2578
+ UPB_INLINE bool google_protobuf_FieldOptions_has_uninterpreted_option(const google_protobuf_FieldOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(28, 32)); }
2422
2579
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_FieldOptions_uninterpreted_option(const google_protobuf_FieldOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len); }
2423
2580
 
2424
2581
  UPB_INLINE void google_protobuf_FieldOptions_set_ctype(google_protobuf_FieldOptions *msg, int32_t value) {
2425
2582
  _upb_sethas(msg, 1);
2426
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)) = value;
2583
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
2427
2584
  }
2428
2585
  UPB_INLINE void google_protobuf_FieldOptions_set_packed(google_protobuf_FieldOptions *msg, bool value) {
2429
2586
  _upb_sethas(msg, 3);
2430
- UPB_FIELD_AT(msg, bool, UPB_SIZE(24, 24)) = value;
2587
+ *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = value;
2431
2588
  }
2432
2589
  UPB_INLINE void google_protobuf_FieldOptions_set_deprecated(google_protobuf_FieldOptions *msg, bool value) {
2433
2590
  _upb_sethas(msg, 4);
2434
- UPB_FIELD_AT(msg, bool, UPB_SIZE(25, 25)) = value;
2591
+ *UPB_PTR_AT(msg, UPB_SIZE(25, 25), bool) = value;
2435
2592
  }
2436
2593
  UPB_INLINE void google_protobuf_FieldOptions_set_lazy(google_protobuf_FieldOptions *msg, bool value) {
2437
2594
  _upb_sethas(msg, 5);
2438
- UPB_FIELD_AT(msg, bool, UPB_SIZE(26, 26)) = value;
2595
+ *UPB_PTR_AT(msg, UPB_SIZE(26, 26), bool) = value;
2439
2596
  }
2440
2597
  UPB_INLINE void google_protobuf_FieldOptions_set_jstype(google_protobuf_FieldOptions *msg, int32_t value) {
2441
2598
  _upb_sethas(msg, 2);
2442
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(16, 16)) = value;
2599
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t) = value;
2443
2600
  }
2444
2601
  UPB_INLINE void google_protobuf_FieldOptions_set_weak(google_protobuf_FieldOptions *msg, bool value) {
2445
2602
  _upb_sethas(msg, 6);
2446
- UPB_FIELD_AT(msg, bool, UPB_SIZE(27, 27)) = value;
2603
+ *UPB_PTR_AT(msg, UPB_SIZE(27, 27), bool) = value;
2447
2604
  }
2448
2605
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_FieldOptions_mutable_uninterpreted_option(google_protobuf_FieldOptions *msg, size_t *len) {
2449
2606
  return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), len);
2450
2607
  }
2451
2608
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_FieldOptions_resize_uninterpreted_option(google_protobuf_FieldOptions *msg, size_t len, upb_arena *arena) {
2452
- return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(28, 32), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2609
+ return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(28, 32), len, UPB_TYPE_MESSAGE, arena);
2453
2610
  }
2454
2611
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_FieldOptions_add_uninterpreted_option(google_protobuf_FieldOptions *msg, upb_arena *arena) {
2455
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2612
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2456
2613
  bool ok = _upb_array_append_accessor(
2457
2614
  msg, UPB_SIZE(28, 32), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2458
2615
  if (!ok) return NULL;
@@ -2462,7 +2619,7 @@ UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_FieldOpti
2462
2619
  /* google.protobuf.OneofOptions */
2463
2620
 
2464
2621
  UPB_INLINE google_protobuf_OneofOptions *google_protobuf_OneofOptions_new(upb_arena *arena) {
2465
- return (google_protobuf_OneofOptions *)upb_msg_new(&google_protobuf_OneofOptions_msginit, arena);
2622
+ return (google_protobuf_OneofOptions *)_upb_msg_new(&google_protobuf_OneofOptions_msginit, arena);
2466
2623
  }
2467
2624
  UPB_INLINE google_protobuf_OneofOptions *google_protobuf_OneofOptions_parse(const char *buf, size_t size,
2468
2625
  upb_arena *arena) {
@@ -2473,16 +2630,17 @@ UPB_INLINE char *google_protobuf_OneofOptions_serialize(const google_protobuf_On
2473
2630
  return upb_encode(msg, &google_protobuf_OneofOptions_msginit, arena, len);
2474
2631
  }
2475
2632
 
2633
+ UPB_INLINE bool google_protobuf_OneofOptions_has_uninterpreted_option(const google_protobuf_OneofOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0)); }
2476
2634
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_OneofOptions_uninterpreted_option(const google_protobuf_OneofOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len); }
2477
2635
 
2478
2636
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_OneofOptions_mutable_uninterpreted_option(google_protobuf_OneofOptions *msg, size_t *len) {
2479
2637
  return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(0, 0), len);
2480
2638
  }
2481
2639
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_OneofOptions_resize_uninterpreted_option(google_protobuf_OneofOptions *msg, size_t len, upb_arena *arena) {
2482
- return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(0, 0), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2640
+ return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(0, 0), len, UPB_TYPE_MESSAGE, arena);
2483
2641
  }
2484
2642
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_OneofOptions_add_uninterpreted_option(google_protobuf_OneofOptions *msg, upb_arena *arena) {
2485
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2643
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2486
2644
  bool ok = _upb_array_append_accessor(
2487
2645
  msg, UPB_SIZE(0, 0), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2488
2646
  if (!ok) return NULL;
@@ -2492,7 +2650,7 @@ UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_OneofOpti
2492
2650
  /* google.protobuf.EnumOptions */
2493
2651
 
2494
2652
  UPB_INLINE google_protobuf_EnumOptions *google_protobuf_EnumOptions_new(upb_arena *arena) {
2495
- return (google_protobuf_EnumOptions *)upb_msg_new(&google_protobuf_EnumOptions_msginit, arena);
2653
+ return (google_protobuf_EnumOptions *)_upb_msg_new(&google_protobuf_EnumOptions_msginit, arena);
2496
2654
  }
2497
2655
  UPB_INLINE google_protobuf_EnumOptions *google_protobuf_EnumOptions_parse(const char *buf, size_t size,
2498
2656
  upb_arena *arena) {
@@ -2504,27 +2662,28 @@ UPB_INLINE char *google_protobuf_EnumOptions_serialize(const google_protobuf_Enu
2504
2662
  }
2505
2663
 
2506
2664
  UPB_INLINE bool google_protobuf_EnumOptions_has_allow_alias(const google_protobuf_EnumOptions *msg) { return _upb_has_field(msg, 1); }
2507
- UPB_INLINE bool google_protobuf_EnumOptions_allow_alias(const google_protobuf_EnumOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)); }
2665
+ UPB_INLINE bool google_protobuf_EnumOptions_allow_alias(const google_protobuf_EnumOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2508
2666
  UPB_INLINE bool google_protobuf_EnumOptions_has_deprecated(const google_protobuf_EnumOptions *msg) { return _upb_has_field(msg, 2); }
2509
- UPB_INLINE bool google_protobuf_EnumOptions_deprecated(const google_protobuf_EnumOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(2, 2)); }
2667
+ UPB_INLINE bool google_protobuf_EnumOptions_deprecated(const google_protobuf_EnumOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool); }
2668
+ UPB_INLINE bool google_protobuf_EnumOptions_has_uninterpreted_option(const google_protobuf_EnumOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(4, 8)); }
2510
2669
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_EnumOptions_uninterpreted_option(const google_protobuf_EnumOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len); }
2511
2670
 
2512
2671
  UPB_INLINE void google_protobuf_EnumOptions_set_allow_alias(google_protobuf_EnumOptions *msg, bool value) {
2513
2672
  _upb_sethas(msg, 1);
2514
- UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)) = value;
2673
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
2515
2674
  }
2516
2675
  UPB_INLINE void google_protobuf_EnumOptions_set_deprecated(google_protobuf_EnumOptions *msg, bool value) {
2517
2676
  _upb_sethas(msg, 2);
2518
- UPB_FIELD_AT(msg, bool, UPB_SIZE(2, 2)) = value;
2677
+ *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = value;
2519
2678
  }
2520
2679
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_EnumOptions_mutable_uninterpreted_option(google_protobuf_EnumOptions *msg, size_t *len) {
2521
2680
  return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
2522
2681
  }
2523
2682
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_EnumOptions_resize_uninterpreted_option(google_protobuf_EnumOptions *msg, size_t len, upb_arena *arena) {
2524
- return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(4, 8), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2683
+ return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(4, 8), len, UPB_TYPE_MESSAGE, arena);
2525
2684
  }
2526
2685
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_EnumOptions_add_uninterpreted_option(google_protobuf_EnumOptions *msg, upb_arena *arena) {
2527
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2686
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2528
2687
  bool ok = _upb_array_append_accessor(
2529
2688
  msg, UPB_SIZE(4, 8), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2530
2689
  if (!ok) return NULL;
@@ -2534,7 +2693,7 @@ UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_EnumOptio
2534
2693
  /* google.protobuf.EnumValueOptions */
2535
2694
 
2536
2695
  UPB_INLINE google_protobuf_EnumValueOptions *google_protobuf_EnumValueOptions_new(upb_arena *arena) {
2537
- return (google_protobuf_EnumValueOptions *)upb_msg_new(&google_protobuf_EnumValueOptions_msginit, arena);
2696
+ return (google_protobuf_EnumValueOptions *)_upb_msg_new(&google_protobuf_EnumValueOptions_msginit, arena);
2538
2697
  }
2539
2698
  UPB_INLINE google_protobuf_EnumValueOptions *google_protobuf_EnumValueOptions_parse(const char *buf, size_t size,
2540
2699
  upb_arena *arena) {
@@ -2546,21 +2705,22 @@ UPB_INLINE char *google_protobuf_EnumValueOptions_serialize(const google_protobu
2546
2705
  }
2547
2706
 
2548
2707
  UPB_INLINE bool google_protobuf_EnumValueOptions_has_deprecated(const google_protobuf_EnumValueOptions *msg) { return _upb_has_field(msg, 1); }
2549
- UPB_INLINE bool google_protobuf_EnumValueOptions_deprecated(const google_protobuf_EnumValueOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)); }
2708
+ UPB_INLINE bool google_protobuf_EnumValueOptions_deprecated(const google_protobuf_EnumValueOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2709
+ UPB_INLINE bool google_protobuf_EnumValueOptions_has_uninterpreted_option(const google_protobuf_EnumValueOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(4, 8)); }
2550
2710
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_EnumValueOptions_uninterpreted_option(const google_protobuf_EnumValueOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len); }
2551
2711
 
2552
2712
  UPB_INLINE void google_protobuf_EnumValueOptions_set_deprecated(google_protobuf_EnumValueOptions *msg, bool value) {
2553
2713
  _upb_sethas(msg, 1);
2554
- UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)) = value;
2714
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
2555
2715
  }
2556
2716
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_EnumValueOptions_mutable_uninterpreted_option(google_protobuf_EnumValueOptions *msg, size_t *len) {
2557
2717
  return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
2558
2718
  }
2559
2719
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_EnumValueOptions_resize_uninterpreted_option(google_protobuf_EnumValueOptions *msg, size_t len, upb_arena *arena) {
2560
- return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(4, 8), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2720
+ return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(4, 8), len, UPB_TYPE_MESSAGE, arena);
2561
2721
  }
2562
2722
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_EnumValueOptions_add_uninterpreted_option(google_protobuf_EnumValueOptions *msg, upb_arena *arena) {
2563
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2723
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2564
2724
  bool ok = _upb_array_append_accessor(
2565
2725
  msg, UPB_SIZE(4, 8), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2566
2726
  if (!ok) return NULL;
@@ -2570,7 +2730,7 @@ UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_EnumValue
2570
2730
  /* google.protobuf.ServiceOptions */
2571
2731
 
2572
2732
  UPB_INLINE google_protobuf_ServiceOptions *google_protobuf_ServiceOptions_new(upb_arena *arena) {
2573
- return (google_protobuf_ServiceOptions *)upb_msg_new(&google_protobuf_ServiceOptions_msginit, arena);
2733
+ return (google_protobuf_ServiceOptions *)_upb_msg_new(&google_protobuf_ServiceOptions_msginit, arena);
2574
2734
  }
2575
2735
  UPB_INLINE google_protobuf_ServiceOptions *google_protobuf_ServiceOptions_parse(const char *buf, size_t size,
2576
2736
  upb_arena *arena) {
@@ -2582,21 +2742,22 @@ UPB_INLINE char *google_protobuf_ServiceOptions_serialize(const google_protobuf_
2582
2742
  }
2583
2743
 
2584
2744
  UPB_INLINE bool google_protobuf_ServiceOptions_has_deprecated(const google_protobuf_ServiceOptions *msg) { return _upb_has_field(msg, 1); }
2585
- UPB_INLINE bool google_protobuf_ServiceOptions_deprecated(const google_protobuf_ServiceOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)); }
2745
+ UPB_INLINE bool google_protobuf_ServiceOptions_deprecated(const google_protobuf_ServiceOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2746
+ UPB_INLINE bool google_protobuf_ServiceOptions_has_uninterpreted_option(const google_protobuf_ServiceOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(4, 8)); }
2586
2747
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_ServiceOptions_uninterpreted_option(const google_protobuf_ServiceOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len); }
2587
2748
 
2588
2749
  UPB_INLINE void google_protobuf_ServiceOptions_set_deprecated(google_protobuf_ServiceOptions *msg, bool value) {
2589
2750
  _upb_sethas(msg, 1);
2590
- UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)) = value;
2751
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
2591
2752
  }
2592
2753
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_ServiceOptions_mutable_uninterpreted_option(google_protobuf_ServiceOptions *msg, size_t *len) {
2593
2754
  return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
2594
2755
  }
2595
2756
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_ServiceOptions_resize_uninterpreted_option(google_protobuf_ServiceOptions *msg, size_t len, upb_arena *arena) {
2596
- return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(4, 8), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2757
+ return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(4, 8), len, UPB_TYPE_MESSAGE, arena);
2597
2758
  }
2598
2759
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_ServiceOptions_add_uninterpreted_option(google_protobuf_ServiceOptions *msg, upb_arena *arena) {
2599
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2760
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2600
2761
  bool ok = _upb_array_append_accessor(
2601
2762
  msg, UPB_SIZE(4, 8), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2602
2763
  if (!ok) return NULL;
@@ -2606,7 +2767,7 @@ UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_ServiceOp
2606
2767
  /* google.protobuf.MethodOptions */
2607
2768
 
2608
2769
  UPB_INLINE google_protobuf_MethodOptions *google_protobuf_MethodOptions_new(upb_arena *arena) {
2609
- return (google_protobuf_MethodOptions *)upb_msg_new(&google_protobuf_MethodOptions_msginit, arena);
2770
+ return (google_protobuf_MethodOptions *)_upb_msg_new(&google_protobuf_MethodOptions_msginit, arena);
2610
2771
  }
2611
2772
  UPB_INLINE google_protobuf_MethodOptions *google_protobuf_MethodOptions_parse(const char *buf, size_t size,
2612
2773
  upb_arena *arena) {
@@ -2618,27 +2779,28 @@ UPB_INLINE char *google_protobuf_MethodOptions_serialize(const google_protobuf_M
2618
2779
  }
2619
2780
 
2620
2781
  UPB_INLINE bool google_protobuf_MethodOptions_has_deprecated(const google_protobuf_MethodOptions *msg) { return _upb_has_field(msg, 2); }
2621
- UPB_INLINE bool google_protobuf_MethodOptions_deprecated(const google_protobuf_MethodOptions *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(16, 16)); }
2782
+ UPB_INLINE bool google_protobuf_MethodOptions_deprecated(const google_protobuf_MethodOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool); }
2622
2783
  UPB_INLINE bool google_protobuf_MethodOptions_has_idempotency_level(const google_protobuf_MethodOptions *msg) { return _upb_has_field(msg, 1); }
2623
- UPB_INLINE int32_t google_protobuf_MethodOptions_idempotency_level(const google_protobuf_MethodOptions *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)); }
2784
+ UPB_INLINE int32_t google_protobuf_MethodOptions_idempotency_level(const google_protobuf_MethodOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
2785
+ UPB_INLINE bool google_protobuf_MethodOptions_has_uninterpreted_option(const google_protobuf_MethodOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(20, 24)); }
2624
2786
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_MethodOptions_uninterpreted_option(const google_protobuf_MethodOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(20, 24), len); }
2625
2787
 
2626
2788
  UPB_INLINE void google_protobuf_MethodOptions_set_deprecated(google_protobuf_MethodOptions *msg, bool value) {
2627
2789
  _upb_sethas(msg, 2);
2628
- UPB_FIELD_AT(msg, bool, UPB_SIZE(16, 16)) = value;
2790
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool) = value;
2629
2791
  }
2630
2792
  UPB_INLINE void google_protobuf_MethodOptions_set_idempotency_level(google_protobuf_MethodOptions *msg, int32_t value) {
2631
2793
  _upb_sethas(msg, 1);
2632
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)) = value;
2794
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
2633
2795
  }
2634
2796
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_MethodOptions_mutable_uninterpreted_option(google_protobuf_MethodOptions *msg, size_t *len) {
2635
2797
  return (google_protobuf_UninterpretedOption**)_upb_array_mutable_accessor(msg, UPB_SIZE(20, 24), len);
2636
2798
  }
2637
2799
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_MethodOptions_resize_uninterpreted_option(google_protobuf_MethodOptions *msg, size_t len, upb_arena *arena) {
2638
- return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(20, 24), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2800
+ return (google_protobuf_UninterpretedOption**)_upb_array_resize_accessor(msg, UPB_SIZE(20, 24), len, UPB_TYPE_MESSAGE, arena);
2639
2801
  }
2640
2802
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_MethodOptions_add_uninterpreted_option(google_protobuf_MethodOptions *msg, upb_arena *arena) {
2641
- struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2803
+ struct google_protobuf_UninterpretedOption* sub = (struct google_protobuf_UninterpretedOption*)_upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2642
2804
  bool ok = _upb_array_append_accessor(
2643
2805
  msg, UPB_SIZE(20, 24), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2644
2806
  if (!ok) return NULL;
@@ -2648,7 +2810,7 @@ UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_MethodOpt
2648
2810
  /* google.protobuf.UninterpretedOption */
2649
2811
 
2650
2812
  UPB_INLINE google_protobuf_UninterpretedOption *google_protobuf_UninterpretedOption_new(upb_arena *arena) {
2651
- return (google_protobuf_UninterpretedOption *)upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2813
+ return (google_protobuf_UninterpretedOption *)_upb_msg_new(&google_protobuf_UninterpretedOption_msginit, arena);
2652
2814
  }
2653
2815
  UPB_INLINE google_protobuf_UninterpretedOption *google_protobuf_UninterpretedOption_parse(const char *buf, size_t size,
2654
2816
  upb_arena *arena) {
@@ -2659,28 +2821,29 @@ UPB_INLINE char *google_protobuf_UninterpretedOption_serialize(const google_prot
2659
2821
  return upb_encode(msg, &google_protobuf_UninterpretedOption_msginit, arena, len);
2660
2822
  }
2661
2823
 
2824
+ UPB_INLINE bool google_protobuf_UninterpretedOption_has_name(const google_protobuf_UninterpretedOption *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(56, 80)); }
2662
2825
  UPB_INLINE const google_protobuf_UninterpretedOption_NamePart* const* google_protobuf_UninterpretedOption_name(const google_protobuf_UninterpretedOption *msg, size_t *len) { return (const google_protobuf_UninterpretedOption_NamePart* const*)_upb_array_accessor(msg, UPB_SIZE(56, 80), len); }
2663
2826
  UPB_INLINE bool google_protobuf_UninterpretedOption_has_identifier_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 4); }
2664
- UPB_INLINE upb_strview google_protobuf_UninterpretedOption_identifier_value(const google_protobuf_UninterpretedOption *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(32, 32)); }
2827
+ UPB_INLINE upb_strview google_protobuf_UninterpretedOption_identifier_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), upb_strview); }
2665
2828
  UPB_INLINE bool google_protobuf_UninterpretedOption_has_positive_int_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 1); }
2666
- UPB_INLINE uint64_t google_protobuf_UninterpretedOption_positive_int_value(const google_protobuf_UninterpretedOption *msg) { return UPB_FIELD_AT(msg, uint64_t, UPB_SIZE(8, 8)); }
2829
+ UPB_INLINE uint64_t google_protobuf_UninterpretedOption_positive_int_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t); }
2667
2830
  UPB_INLINE bool google_protobuf_UninterpretedOption_has_negative_int_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 2); }
2668
- UPB_INLINE int64_t google_protobuf_UninterpretedOption_negative_int_value(const google_protobuf_UninterpretedOption *msg) { return UPB_FIELD_AT(msg, int64_t, UPB_SIZE(16, 16)); }
2831
+ UPB_INLINE int64_t google_protobuf_UninterpretedOption_negative_int_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int64_t); }
2669
2832
  UPB_INLINE bool google_protobuf_UninterpretedOption_has_double_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 3); }
2670
- UPB_INLINE double google_protobuf_UninterpretedOption_double_value(const google_protobuf_UninterpretedOption *msg) { return UPB_FIELD_AT(msg, double, UPB_SIZE(24, 24)); }
2833
+ UPB_INLINE double google_protobuf_UninterpretedOption_double_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), double); }
2671
2834
  UPB_INLINE bool google_protobuf_UninterpretedOption_has_string_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 5); }
2672
- UPB_INLINE upb_strview google_protobuf_UninterpretedOption_string_value(const google_protobuf_UninterpretedOption *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(40, 48)); }
2835
+ UPB_INLINE upb_strview google_protobuf_UninterpretedOption_string_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(40, 48), upb_strview); }
2673
2836
  UPB_INLINE bool google_protobuf_UninterpretedOption_has_aggregate_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 6); }
2674
- UPB_INLINE upb_strview google_protobuf_UninterpretedOption_aggregate_value(const google_protobuf_UninterpretedOption *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(48, 64)); }
2837
+ UPB_INLINE upb_strview google_protobuf_UninterpretedOption_aggregate_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(48, 64), upb_strview); }
2675
2838
 
2676
2839
  UPB_INLINE google_protobuf_UninterpretedOption_NamePart** google_protobuf_UninterpretedOption_mutable_name(google_protobuf_UninterpretedOption *msg, size_t *len) {
2677
2840
  return (google_protobuf_UninterpretedOption_NamePart**)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 80), len);
2678
2841
  }
2679
2842
  UPB_INLINE google_protobuf_UninterpretedOption_NamePart** google_protobuf_UninterpretedOption_resize_name(google_protobuf_UninterpretedOption *msg, size_t len, upb_arena *arena) {
2680
- return (google_protobuf_UninterpretedOption_NamePart**)_upb_array_resize_accessor(msg, UPB_SIZE(56, 80), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2843
+ return (google_protobuf_UninterpretedOption_NamePart**)_upb_array_resize_accessor(msg, UPB_SIZE(56, 80), len, UPB_TYPE_MESSAGE, arena);
2681
2844
  }
2682
2845
  UPB_INLINE struct google_protobuf_UninterpretedOption_NamePart* google_protobuf_UninterpretedOption_add_name(google_protobuf_UninterpretedOption *msg, upb_arena *arena) {
2683
- struct google_protobuf_UninterpretedOption_NamePart* sub = (struct google_protobuf_UninterpretedOption_NamePart*)upb_msg_new(&google_protobuf_UninterpretedOption_NamePart_msginit, arena);
2846
+ struct google_protobuf_UninterpretedOption_NamePart* sub = (struct google_protobuf_UninterpretedOption_NamePart*)_upb_msg_new(&google_protobuf_UninterpretedOption_NamePart_msginit, arena);
2684
2847
  bool ok = _upb_array_append_accessor(
2685
2848
  msg, UPB_SIZE(56, 80), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2686
2849
  if (!ok) return NULL;
@@ -2688,33 +2851,33 @@ UPB_INLINE struct google_protobuf_UninterpretedOption_NamePart* google_protobuf_
2688
2851
  }
2689
2852
  UPB_INLINE void google_protobuf_UninterpretedOption_set_identifier_value(google_protobuf_UninterpretedOption *msg, upb_strview value) {
2690
2853
  _upb_sethas(msg, 4);
2691
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(32, 32)) = value;
2854
+ *UPB_PTR_AT(msg, UPB_SIZE(32, 32), upb_strview) = value;
2692
2855
  }
2693
2856
  UPB_INLINE void google_protobuf_UninterpretedOption_set_positive_int_value(google_protobuf_UninterpretedOption *msg, uint64_t value) {
2694
2857
  _upb_sethas(msg, 1);
2695
- UPB_FIELD_AT(msg, uint64_t, UPB_SIZE(8, 8)) = value;
2858
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t) = value;
2696
2859
  }
2697
2860
  UPB_INLINE void google_protobuf_UninterpretedOption_set_negative_int_value(google_protobuf_UninterpretedOption *msg, int64_t value) {
2698
2861
  _upb_sethas(msg, 2);
2699
- UPB_FIELD_AT(msg, int64_t, UPB_SIZE(16, 16)) = value;
2862
+ *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int64_t) = value;
2700
2863
  }
2701
2864
  UPB_INLINE void google_protobuf_UninterpretedOption_set_double_value(google_protobuf_UninterpretedOption *msg, double value) {
2702
2865
  _upb_sethas(msg, 3);
2703
- UPB_FIELD_AT(msg, double, UPB_SIZE(24, 24)) = value;
2866
+ *UPB_PTR_AT(msg, UPB_SIZE(24, 24), double) = value;
2704
2867
  }
2705
2868
  UPB_INLINE void google_protobuf_UninterpretedOption_set_string_value(google_protobuf_UninterpretedOption *msg, upb_strview value) {
2706
2869
  _upb_sethas(msg, 5);
2707
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(40, 48)) = value;
2870
+ *UPB_PTR_AT(msg, UPB_SIZE(40, 48), upb_strview) = value;
2708
2871
  }
2709
2872
  UPB_INLINE void google_protobuf_UninterpretedOption_set_aggregate_value(google_protobuf_UninterpretedOption *msg, upb_strview value) {
2710
2873
  _upb_sethas(msg, 6);
2711
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(48, 64)) = value;
2874
+ *UPB_PTR_AT(msg, UPB_SIZE(48, 64), upb_strview) = value;
2712
2875
  }
2713
2876
 
2714
2877
  /* google.protobuf.UninterpretedOption.NamePart */
2715
2878
 
2716
2879
  UPB_INLINE google_protobuf_UninterpretedOption_NamePart *google_protobuf_UninterpretedOption_NamePart_new(upb_arena *arena) {
2717
- return (google_protobuf_UninterpretedOption_NamePart *)upb_msg_new(&google_protobuf_UninterpretedOption_NamePart_msginit, arena);
2880
+ return (google_protobuf_UninterpretedOption_NamePart *)_upb_msg_new(&google_protobuf_UninterpretedOption_NamePart_msginit, arena);
2718
2881
  }
2719
2882
  UPB_INLINE google_protobuf_UninterpretedOption_NamePart *google_protobuf_UninterpretedOption_NamePart_parse(const char *buf, size_t size,
2720
2883
  upb_arena *arena) {
@@ -2726,23 +2889,23 @@ UPB_INLINE char *google_protobuf_UninterpretedOption_NamePart_serialize(const go
2726
2889
  }
2727
2890
 
2728
2891
  UPB_INLINE bool google_protobuf_UninterpretedOption_NamePart_has_name_part(const google_protobuf_UninterpretedOption_NamePart *msg) { return _upb_has_field(msg, 2); }
2729
- UPB_INLINE upb_strview google_protobuf_UninterpretedOption_NamePart_name_part(const google_protobuf_UninterpretedOption_NamePart *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)); }
2892
+ UPB_INLINE upb_strview google_protobuf_UninterpretedOption_NamePart_name_part(const google_protobuf_UninterpretedOption_NamePart *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
2730
2893
  UPB_INLINE bool google_protobuf_UninterpretedOption_NamePart_has_is_extension(const google_protobuf_UninterpretedOption_NamePart *msg) { return _upb_has_field(msg, 1); }
2731
- UPB_INLINE bool google_protobuf_UninterpretedOption_NamePart_is_extension(const google_protobuf_UninterpretedOption_NamePart *msg) { return UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)); }
2894
+ UPB_INLINE bool google_protobuf_UninterpretedOption_NamePart_is_extension(const google_protobuf_UninterpretedOption_NamePart *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2732
2895
 
2733
2896
  UPB_INLINE void google_protobuf_UninterpretedOption_NamePart_set_name_part(google_protobuf_UninterpretedOption_NamePart *msg, upb_strview value) {
2734
2897
  _upb_sethas(msg, 2);
2735
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)) = value;
2898
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview) = value;
2736
2899
  }
2737
2900
  UPB_INLINE void google_protobuf_UninterpretedOption_NamePart_set_is_extension(google_protobuf_UninterpretedOption_NamePart *msg, bool value) {
2738
2901
  _upb_sethas(msg, 1);
2739
- UPB_FIELD_AT(msg, bool, UPB_SIZE(1, 1)) = value;
2902
+ *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
2740
2903
  }
2741
2904
 
2742
2905
  /* google.protobuf.SourceCodeInfo */
2743
2906
 
2744
2907
  UPB_INLINE google_protobuf_SourceCodeInfo *google_protobuf_SourceCodeInfo_new(upb_arena *arena) {
2745
- return (google_protobuf_SourceCodeInfo *)upb_msg_new(&google_protobuf_SourceCodeInfo_msginit, arena);
2908
+ return (google_protobuf_SourceCodeInfo *)_upb_msg_new(&google_protobuf_SourceCodeInfo_msginit, arena);
2746
2909
  }
2747
2910
  UPB_INLINE google_protobuf_SourceCodeInfo *google_protobuf_SourceCodeInfo_parse(const char *buf, size_t size,
2748
2911
  upb_arena *arena) {
@@ -2753,16 +2916,17 @@ UPB_INLINE char *google_protobuf_SourceCodeInfo_serialize(const google_protobuf_
2753
2916
  return upb_encode(msg, &google_protobuf_SourceCodeInfo_msginit, arena, len);
2754
2917
  }
2755
2918
 
2919
+ UPB_INLINE bool google_protobuf_SourceCodeInfo_has_location(const google_protobuf_SourceCodeInfo *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0)); }
2756
2920
  UPB_INLINE const google_protobuf_SourceCodeInfo_Location* const* google_protobuf_SourceCodeInfo_location(const google_protobuf_SourceCodeInfo *msg, size_t *len) { return (const google_protobuf_SourceCodeInfo_Location* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len); }
2757
2921
 
2758
2922
  UPB_INLINE google_protobuf_SourceCodeInfo_Location** google_protobuf_SourceCodeInfo_mutable_location(google_protobuf_SourceCodeInfo *msg, size_t *len) {
2759
2923
  return (google_protobuf_SourceCodeInfo_Location**)_upb_array_mutable_accessor(msg, UPB_SIZE(0, 0), len);
2760
2924
  }
2761
2925
  UPB_INLINE google_protobuf_SourceCodeInfo_Location** google_protobuf_SourceCodeInfo_resize_location(google_protobuf_SourceCodeInfo *msg, size_t len, upb_arena *arena) {
2762
- return (google_protobuf_SourceCodeInfo_Location**)_upb_array_resize_accessor(msg, UPB_SIZE(0, 0), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
2926
+ return (google_protobuf_SourceCodeInfo_Location**)_upb_array_resize_accessor(msg, UPB_SIZE(0, 0), len, UPB_TYPE_MESSAGE, arena);
2763
2927
  }
2764
2928
  UPB_INLINE struct google_protobuf_SourceCodeInfo_Location* google_protobuf_SourceCodeInfo_add_location(google_protobuf_SourceCodeInfo *msg, upb_arena *arena) {
2765
- struct google_protobuf_SourceCodeInfo_Location* sub = (struct google_protobuf_SourceCodeInfo_Location*)upb_msg_new(&google_protobuf_SourceCodeInfo_Location_msginit, arena);
2929
+ struct google_protobuf_SourceCodeInfo_Location* sub = (struct google_protobuf_SourceCodeInfo_Location*)_upb_msg_new(&google_protobuf_SourceCodeInfo_Location_msginit, arena);
2766
2930
  bool ok = _upb_array_append_accessor(
2767
2931
  msg, UPB_SIZE(0, 0), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2768
2932
  if (!ok) return NULL;
@@ -2772,7 +2936,7 @@ UPB_INLINE struct google_protobuf_SourceCodeInfo_Location* google_protobuf_Sourc
2772
2936
  /* google.protobuf.SourceCodeInfo.Location */
2773
2937
 
2774
2938
  UPB_INLINE google_protobuf_SourceCodeInfo_Location *google_protobuf_SourceCodeInfo_Location_new(upb_arena *arena) {
2775
- return (google_protobuf_SourceCodeInfo_Location *)upb_msg_new(&google_protobuf_SourceCodeInfo_Location_msginit, arena);
2939
+ return (google_protobuf_SourceCodeInfo_Location *)_upb_msg_new(&google_protobuf_SourceCodeInfo_Location_msginit, arena);
2776
2940
  }
2777
2941
  UPB_INLINE google_protobuf_SourceCodeInfo_Location *google_protobuf_SourceCodeInfo_Location_parse(const char *buf, size_t size,
2778
2942
  upb_arena *arena) {
@@ -2786,54 +2950,54 @@ UPB_INLINE char *google_protobuf_SourceCodeInfo_Location_serialize(const google_
2786
2950
  UPB_INLINE int32_t const* google_protobuf_SourceCodeInfo_Location_path(const google_protobuf_SourceCodeInfo_Location *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(20, 40), len); }
2787
2951
  UPB_INLINE int32_t const* google_protobuf_SourceCodeInfo_Location_span(const google_protobuf_SourceCodeInfo_Location *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len); }
2788
2952
  UPB_INLINE bool google_protobuf_SourceCodeInfo_Location_has_leading_comments(const google_protobuf_SourceCodeInfo_Location *msg) { return _upb_has_field(msg, 1); }
2789
- UPB_INLINE upb_strview google_protobuf_SourceCodeInfo_Location_leading_comments(const google_protobuf_SourceCodeInfo_Location *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)); }
2953
+ UPB_INLINE upb_strview google_protobuf_SourceCodeInfo_Location_leading_comments(const google_protobuf_SourceCodeInfo_Location *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
2790
2954
  UPB_INLINE bool google_protobuf_SourceCodeInfo_Location_has_trailing_comments(const google_protobuf_SourceCodeInfo_Location *msg) { return _upb_has_field(msg, 2); }
2791
- UPB_INLINE upb_strview google_protobuf_SourceCodeInfo_Location_trailing_comments(const google_protobuf_SourceCodeInfo_Location *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(12, 24)); }
2955
+ UPB_INLINE upb_strview google_protobuf_SourceCodeInfo_Location_trailing_comments(const google_protobuf_SourceCodeInfo_Location *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_strview); }
2792
2956
  UPB_INLINE upb_strview const* google_protobuf_SourceCodeInfo_Location_leading_detached_comments(const google_protobuf_SourceCodeInfo_Location *msg, size_t *len) { return (upb_strview const*)_upb_array_accessor(msg, UPB_SIZE(28, 56), len); }
2793
2957
 
2794
2958
  UPB_INLINE int32_t* google_protobuf_SourceCodeInfo_Location_mutable_path(google_protobuf_SourceCodeInfo_Location *msg, size_t *len) {
2795
2959
  return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(20, 40), len);
2796
2960
  }
2797
2961
  UPB_INLINE int32_t* google_protobuf_SourceCodeInfo_Location_resize_path(google_protobuf_SourceCodeInfo_Location *msg, size_t len, upb_arena *arena) {
2798
- return (int32_t*)_upb_array_resize_accessor(msg, UPB_SIZE(20, 40), len, UPB_SIZE(4, 4), UPB_TYPE_INT32, arena);
2962
+ return (int32_t*)_upb_array_resize_accessor(msg, UPB_SIZE(20, 40), len, UPB_TYPE_INT32, arena);
2799
2963
  }
2800
2964
  UPB_INLINE bool google_protobuf_SourceCodeInfo_Location_add_path(google_protobuf_SourceCodeInfo_Location *msg, int32_t val, upb_arena *arena) {
2801
- return _upb_array_append_accessor(
2802
- msg, UPB_SIZE(20, 40), UPB_SIZE(4, 4), UPB_TYPE_INT32, &val, arena);
2965
+ return _upb_array_append_accessor(msg, UPB_SIZE(20, 40), UPB_SIZE(4, 4), UPB_TYPE_INT32, &val,
2966
+ arena);
2803
2967
  }
2804
2968
  UPB_INLINE int32_t* google_protobuf_SourceCodeInfo_Location_mutable_span(google_protobuf_SourceCodeInfo_Location *msg, size_t *len) {
2805
2969
  return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 48), len);
2806
2970
  }
2807
2971
  UPB_INLINE int32_t* google_protobuf_SourceCodeInfo_Location_resize_span(google_protobuf_SourceCodeInfo_Location *msg, size_t len, upb_arena *arena) {
2808
- return (int32_t*)_upb_array_resize_accessor(msg, UPB_SIZE(24, 48), len, UPB_SIZE(4, 4), UPB_TYPE_INT32, arena);
2972
+ return (int32_t*)_upb_array_resize_accessor(msg, UPB_SIZE(24, 48), len, UPB_TYPE_INT32, arena);
2809
2973
  }
2810
2974
  UPB_INLINE bool google_protobuf_SourceCodeInfo_Location_add_span(google_protobuf_SourceCodeInfo_Location *msg, int32_t val, upb_arena *arena) {
2811
- return _upb_array_append_accessor(
2812
- msg, UPB_SIZE(24, 48), UPB_SIZE(4, 4), UPB_TYPE_INT32, &val, arena);
2975
+ return _upb_array_append_accessor(msg, UPB_SIZE(24, 48), UPB_SIZE(4, 4), UPB_TYPE_INT32, &val,
2976
+ arena);
2813
2977
  }
2814
2978
  UPB_INLINE void google_protobuf_SourceCodeInfo_Location_set_leading_comments(google_protobuf_SourceCodeInfo_Location *msg, upb_strview value) {
2815
2979
  _upb_sethas(msg, 1);
2816
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(4, 8)) = value;
2980
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview) = value;
2817
2981
  }
2818
2982
  UPB_INLINE void google_protobuf_SourceCodeInfo_Location_set_trailing_comments(google_protobuf_SourceCodeInfo_Location *msg, upb_strview value) {
2819
2983
  _upb_sethas(msg, 2);
2820
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(12, 24)) = value;
2984
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_strview) = value;
2821
2985
  }
2822
2986
  UPB_INLINE upb_strview* google_protobuf_SourceCodeInfo_Location_mutable_leading_detached_comments(google_protobuf_SourceCodeInfo_Location *msg, size_t *len) {
2823
2987
  return (upb_strview*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 56), len);
2824
2988
  }
2825
2989
  UPB_INLINE upb_strview* google_protobuf_SourceCodeInfo_Location_resize_leading_detached_comments(google_protobuf_SourceCodeInfo_Location *msg, size_t len, upb_arena *arena) {
2826
- return (upb_strview*)_upb_array_resize_accessor(msg, UPB_SIZE(28, 56), len, UPB_SIZE(8, 16), UPB_TYPE_STRING, arena);
2990
+ return (upb_strview*)_upb_array_resize_accessor(msg, UPB_SIZE(28, 56), len, UPB_TYPE_STRING, arena);
2827
2991
  }
2828
2992
  UPB_INLINE bool google_protobuf_SourceCodeInfo_Location_add_leading_detached_comments(google_protobuf_SourceCodeInfo_Location *msg, upb_strview val, upb_arena *arena) {
2829
- return _upb_array_append_accessor(
2830
- msg, UPB_SIZE(28, 56), UPB_SIZE(8, 16), UPB_TYPE_STRING, &val, arena);
2993
+ return _upb_array_append_accessor(msg, UPB_SIZE(28, 56), UPB_SIZE(8, 16), UPB_TYPE_STRING, &val,
2994
+ arena);
2831
2995
  }
2832
2996
 
2833
2997
  /* google.protobuf.GeneratedCodeInfo */
2834
2998
 
2835
2999
  UPB_INLINE google_protobuf_GeneratedCodeInfo *google_protobuf_GeneratedCodeInfo_new(upb_arena *arena) {
2836
- return (google_protobuf_GeneratedCodeInfo *)upb_msg_new(&google_protobuf_GeneratedCodeInfo_msginit, arena);
3000
+ return (google_protobuf_GeneratedCodeInfo *)_upb_msg_new(&google_protobuf_GeneratedCodeInfo_msginit, arena);
2837
3001
  }
2838
3002
  UPB_INLINE google_protobuf_GeneratedCodeInfo *google_protobuf_GeneratedCodeInfo_parse(const char *buf, size_t size,
2839
3003
  upb_arena *arena) {
@@ -2844,16 +3008,17 @@ UPB_INLINE char *google_protobuf_GeneratedCodeInfo_serialize(const google_protob
2844
3008
  return upb_encode(msg, &google_protobuf_GeneratedCodeInfo_msginit, arena, len);
2845
3009
  }
2846
3010
 
3011
+ UPB_INLINE bool google_protobuf_GeneratedCodeInfo_has_annotation(const google_protobuf_GeneratedCodeInfo *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0)); }
2847
3012
  UPB_INLINE const google_protobuf_GeneratedCodeInfo_Annotation* const* google_protobuf_GeneratedCodeInfo_annotation(const google_protobuf_GeneratedCodeInfo *msg, size_t *len) { return (const google_protobuf_GeneratedCodeInfo_Annotation* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len); }
2848
3013
 
2849
3014
  UPB_INLINE google_protobuf_GeneratedCodeInfo_Annotation** google_protobuf_GeneratedCodeInfo_mutable_annotation(google_protobuf_GeneratedCodeInfo *msg, size_t *len) {
2850
3015
  return (google_protobuf_GeneratedCodeInfo_Annotation**)_upb_array_mutable_accessor(msg, UPB_SIZE(0, 0), len);
2851
3016
  }
2852
3017
  UPB_INLINE google_protobuf_GeneratedCodeInfo_Annotation** google_protobuf_GeneratedCodeInfo_resize_annotation(google_protobuf_GeneratedCodeInfo *msg, size_t len, upb_arena *arena) {
2853
- return (google_protobuf_GeneratedCodeInfo_Annotation**)_upb_array_resize_accessor(msg, UPB_SIZE(0, 0), len, UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, arena);
3018
+ return (google_protobuf_GeneratedCodeInfo_Annotation**)_upb_array_resize_accessor(msg, UPB_SIZE(0, 0), len, UPB_TYPE_MESSAGE, arena);
2854
3019
  }
2855
3020
  UPB_INLINE struct google_protobuf_GeneratedCodeInfo_Annotation* google_protobuf_GeneratedCodeInfo_add_annotation(google_protobuf_GeneratedCodeInfo *msg, upb_arena *arena) {
2856
- struct google_protobuf_GeneratedCodeInfo_Annotation* sub = (struct google_protobuf_GeneratedCodeInfo_Annotation*)upb_msg_new(&google_protobuf_GeneratedCodeInfo_Annotation_msginit, arena);
3021
+ struct google_protobuf_GeneratedCodeInfo_Annotation* sub = (struct google_protobuf_GeneratedCodeInfo_Annotation*)_upb_msg_new(&google_protobuf_GeneratedCodeInfo_Annotation_msginit, arena);
2857
3022
  bool ok = _upb_array_append_accessor(
2858
3023
  msg, UPB_SIZE(0, 0), UPB_SIZE(4, 8), UPB_TYPE_MESSAGE, &sub, arena);
2859
3024
  if (!ok) return NULL;
@@ -2863,7 +3028,7 @@ UPB_INLINE struct google_protobuf_GeneratedCodeInfo_Annotation* google_protobuf_
2863
3028
  /* google.protobuf.GeneratedCodeInfo.Annotation */
2864
3029
 
2865
3030
  UPB_INLINE google_protobuf_GeneratedCodeInfo_Annotation *google_protobuf_GeneratedCodeInfo_Annotation_new(upb_arena *arena) {
2866
- return (google_protobuf_GeneratedCodeInfo_Annotation *)upb_msg_new(&google_protobuf_GeneratedCodeInfo_Annotation_msginit, arena);
3031
+ return (google_protobuf_GeneratedCodeInfo_Annotation *)_upb_msg_new(&google_protobuf_GeneratedCodeInfo_Annotation_msginit, arena);
2867
3032
  }
2868
3033
  UPB_INLINE google_protobuf_GeneratedCodeInfo_Annotation *google_protobuf_GeneratedCodeInfo_Annotation_parse(const char *buf, size_t size,
2869
3034
  upb_arena *arena) {
@@ -2876,33 +3041,33 @@ UPB_INLINE char *google_protobuf_GeneratedCodeInfo_Annotation_serialize(const go
2876
3041
 
2877
3042
  UPB_INLINE int32_t const* google_protobuf_GeneratedCodeInfo_Annotation_path(const google_protobuf_GeneratedCodeInfo_Annotation *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(20, 32), len); }
2878
3043
  UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_has_source_file(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return _upb_has_field(msg, 3); }
2879
- UPB_INLINE upb_strview google_protobuf_GeneratedCodeInfo_Annotation_source_file(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(12, 16)); }
3044
+ UPB_INLINE upb_strview google_protobuf_GeneratedCodeInfo_Annotation_source_file(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 16), upb_strview); }
2880
3045
  UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_has_begin(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return _upb_has_field(msg, 1); }
2881
- UPB_INLINE int32_t google_protobuf_GeneratedCodeInfo_Annotation_begin(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(4, 4)); }
3046
+ UPB_INLINE int32_t google_protobuf_GeneratedCodeInfo_Annotation_begin(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t); }
2882
3047
  UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_has_end(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return _upb_has_field(msg, 2); }
2883
- UPB_INLINE int32_t google_protobuf_GeneratedCodeInfo_Annotation_end(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)); }
3048
+ UPB_INLINE int32_t google_protobuf_GeneratedCodeInfo_Annotation_end(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
2884
3049
 
2885
3050
  UPB_INLINE int32_t* google_protobuf_GeneratedCodeInfo_Annotation_mutable_path(google_protobuf_GeneratedCodeInfo_Annotation *msg, size_t *len) {
2886
3051
  return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(20, 32), len);
2887
3052
  }
2888
3053
  UPB_INLINE int32_t* google_protobuf_GeneratedCodeInfo_Annotation_resize_path(google_protobuf_GeneratedCodeInfo_Annotation *msg, size_t len, upb_arena *arena) {
2889
- return (int32_t*)_upb_array_resize_accessor(msg, UPB_SIZE(20, 32), len, UPB_SIZE(4, 4), UPB_TYPE_INT32, arena);
3054
+ return (int32_t*)_upb_array_resize_accessor(msg, UPB_SIZE(20, 32), len, UPB_TYPE_INT32, arena);
2890
3055
  }
2891
3056
  UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_add_path(google_protobuf_GeneratedCodeInfo_Annotation *msg, int32_t val, upb_arena *arena) {
2892
- return _upb_array_append_accessor(
2893
- msg, UPB_SIZE(20, 32), UPB_SIZE(4, 4), UPB_TYPE_INT32, &val, arena);
3057
+ return _upb_array_append_accessor(msg, UPB_SIZE(20, 32), UPB_SIZE(4, 4), UPB_TYPE_INT32, &val,
3058
+ arena);
2894
3059
  }
2895
3060
  UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_set_source_file(google_protobuf_GeneratedCodeInfo_Annotation *msg, upb_strview value) {
2896
3061
  _upb_sethas(msg, 3);
2897
- UPB_FIELD_AT(msg, upb_strview, UPB_SIZE(12, 16)) = value;
3062
+ *UPB_PTR_AT(msg, UPB_SIZE(12, 16), upb_strview) = value;
2898
3063
  }
2899
3064
  UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_set_begin(google_protobuf_GeneratedCodeInfo_Annotation *msg, int32_t value) {
2900
3065
  _upb_sethas(msg, 1);
2901
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(4, 4)) = value;
3066
+ *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = value;
2902
3067
  }
2903
3068
  UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_set_end(google_protobuf_GeneratedCodeInfo_Annotation *msg, int32_t value) {
2904
3069
  _upb_sethas(msg, 2);
2905
- UPB_FIELD_AT(msg, int32_t, UPB_SIZE(8, 8)) = value;
3070
+ *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = value;
2906
3071
  }
2907
3072
 
2908
3073
  #ifdef __cplusplus
@@ -2915,38 +3080,23 @@ UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_set_end(google_prot
2915
3080
  ** Defs are upb's internal representation of the constructs that can appear
2916
3081
  ** in a .proto file:
2917
3082
  **
2918
- ** - upb::MessageDefPtr (upb_msgdef): describes a "message" construct.
2919
- ** - upb::FieldDefPtr (upb_fielddef): describes a message field.
2920
- ** - upb::FileDefPtr (upb_filedef): describes a .proto file and its defs.
2921
- ** - upb::EnumDefPtr (upb_enumdef): describes an enum.
2922
- ** - upb::OneofDefPtr (upb_oneofdef): describes a oneof.
3083
+ ** - upb_msgdef: describes a "message" construct.
3084
+ ** - upb_fielddef: describes a message field.
3085
+ ** - upb_filedef: describes a .proto file and its defs.
3086
+ ** - upb_enumdef: describes an enum.
3087
+ ** - upb_oneofdef: describes a oneof.
2923
3088
  **
2924
3089
  ** TODO: definitions of services.
2925
- **
2926
- ** This is a mixed C/C++ interface that offers a full API to both languages.
2927
- ** See the top-level README for more information.
2928
3090
  */
2929
3091
 
2930
3092
  #ifndef UPB_DEF_H_
2931
3093
  #define UPB_DEF_H_
2932
3094
 
2933
3095
 
2934
- #ifdef __cplusplus
2935
- #include <cstring>
2936
- #include <memory>
2937
- #include <string>
2938
- #include <vector>
2939
-
2940
- namespace upb {
2941
- class EnumDefPtr;
2942
- class FieldDefPtr;
2943
- class FileDefPtr;
2944
- class MessageDefPtr;
2945
- class OneofDefPtr;
2946
- class SymbolTable;
2947
- }
2948
- #endif
2949
3096
 
3097
+ #ifdef __cplusplus
3098
+ extern "C" {
3099
+ #endif /* __cplusplus */
2950
3100
 
2951
3101
  struct upb_enumdef;
2952
3102
  typedef struct upb_enumdef upb_enumdef;
@@ -2998,22 +3148,20 @@ typedef enum {
2998
3148
  * protobuf wire format. */
2999
3149
  #define UPB_MAX_FIELDNUMBER ((1 << 29) - 1)
3000
3150
 
3001
- #ifdef __cplusplus
3002
- extern "C" {
3003
- #endif
3004
-
3005
3151
  const char *upb_fielddef_fullname(const upb_fielddef *f);
3006
3152
  upb_fieldtype_t upb_fielddef_type(const upb_fielddef *f);
3007
3153
  upb_descriptortype_t upb_fielddef_descriptortype(const upb_fielddef *f);
3008
3154
  upb_label_t upb_fielddef_label(const upb_fielddef *f);
3009
3155
  uint32_t upb_fielddef_number(const upb_fielddef *f);
3010
3156
  const char *upb_fielddef_name(const upb_fielddef *f);
3157
+ const char *upb_fielddef_jsonname(const upb_fielddef *f);
3011
3158
  bool upb_fielddef_isextension(const upb_fielddef *f);
3012
3159
  bool upb_fielddef_lazy(const upb_fielddef *f);
3013
3160
  bool upb_fielddef_packed(const upb_fielddef *f);
3014
- size_t upb_fielddef_getjsonname(const upb_fielddef *f, char *buf, size_t len);
3161
+ const upb_filedef *upb_fielddef_file(const upb_fielddef *f);
3015
3162
  const upb_msgdef *upb_fielddef_containingtype(const upb_fielddef *f);
3016
3163
  const upb_oneofdef *upb_fielddef_containingoneof(const upb_fielddef *f);
3164
+ const upb_oneofdef *upb_fielddef_realcontainingoneof(const upb_fielddef *f);
3017
3165
  uint32_t upb_fielddef_index(const upb_fielddef *f);
3018
3166
  bool upb_fielddef_issubmsg(const upb_fielddef *f);
3019
3167
  bool upb_fielddef_isstring(const upb_fielddef *f);
@@ -3032,155 +3180,20 @@ bool upb_fielddef_hassubdef(const upb_fielddef *f);
3032
3180
  bool upb_fielddef_haspresence(const upb_fielddef *f);
3033
3181
  const upb_msgdef *upb_fielddef_msgsubdef(const upb_fielddef *f);
3034
3182
  const upb_enumdef *upb_fielddef_enumsubdef(const upb_fielddef *f);
3183
+ const upb_msglayout_field *upb_fielddef_layout(const upb_fielddef *f);
3035
3184
 
3036
3185
  /* Internal only. */
3037
3186
  uint32_t upb_fielddef_selectorbase(const upb_fielddef *f);
3038
3187
 
3039
- #ifdef __cplusplus
3040
- } /* extern "C" */
3041
-
3042
- /* A upb_fielddef describes a single field in a message. It is most often
3043
- * found as a part of a upb_msgdef, but can also stand alone to represent
3044
- * an extension. */
3045
- class upb::FieldDefPtr {
3046
- public:
3047
- FieldDefPtr() : ptr_(nullptr) {}
3048
- explicit FieldDefPtr(const upb_fielddef *ptr) : ptr_(ptr) {}
3049
-
3050
- const upb_fielddef* ptr() const { return ptr_; }
3051
- explicit operator bool() const { return ptr_ != nullptr; }
3052
-
3053
- typedef upb_fieldtype_t Type;
3054
- typedef upb_label_t Label;
3055
- typedef upb_descriptortype_t DescriptorType;
3056
-
3057
- const char* full_name() const { return upb_fielddef_fullname(ptr_); }
3058
-
3059
- Type type() const { return upb_fielddef_type(ptr_); }
3060
- Label label() const { return upb_fielddef_label(ptr_); }
3061
- const char* name() const { return upb_fielddef_name(ptr_); }
3062
- uint32_t number() const { return upb_fielddef_number(ptr_); }
3063
- bool is_extension() const { return upb_fielddef_isextension(ptr_); }
3064
-
3065
- /* Copies the JSON name for this field into the given buffer. Returns the
3066
- * actual size of the JSON name, including the NULL terminator. If the
3067
- * return value is 0, the JSON name is unset. If the return value is
3068
- * greater than len, the JSON name was truncated. The buffer is always
3069
- * NULL-terminated if len > 0.
3070
- *
3071
- * The JSON name always defaults to a camelCased version of the regular
3072
- * name. However if the regular name is unset, the JSON name will be unset
3073
- * also.
3074
- */
3075
- size_t GetJsonName(char *buf, size_t len) const {
3076
- return upb_fielddef_getjsonname(ptr_, buf, len);
3077
- }
3078
-
3079
- /* Convenience version of the above function which copies the JSON name
3080
- * into the given string, returning false if the name is not set. */
3081
- template <class T>
3082
- bool GetJsonName(T* str) {
3083
- str->resize(GetJsonName(NULL, 0));
3084
- GetJsonName(&(*str)[0], str->size());
3085
- return str->size() > 0;
3086
- }
3087
-
3088
- /* For UPB_TYPE_MESSAGE fields only where is_tag_delimited() == false,
3089
- * indicates whether this field should have lazy parsing handlers that yield
3090
- * the unparsed string for the submessage.
3091
- *
3092
- * TODO(haberman): I think we want to move this into a FieldOptions container
3093
- * when we add support for custom options (the FieldOptions struct will
3094
- * contain both regular FieldOptions like "lazy" *and* custom options). */
3095
- bool lazy() const { return upb_fielddef_lazy(ptr_); }
3096
-
3097
- /* For non-string, non-submessage fields, this indicates whether binary
3098
- * protobufs are encoded in packed or non-packed format.
3099
- *
3100
- * TODO(haberman): see note above about putting options like this into a
3101
- * FieldOptions container. */
3102
- bool packed() const { return upb_fielddef_packed(ptr_); }
3103
-
3104
- /* An integer that can be used as an index into an array of fields for
3105
- * whatever message this field belongs to. Guaranteed to be less than
3106
- * f->containing_type()->field_count(). May only be accessed once the def has
3107
- * been finalized. */
3108
- uint32_t index() const { return upb_fielddef_index(ptr_); }
3109
-
3110
- /* The MessageDef to which this field belongs.
3111
- *
3112
- * If this field has been added to a MessageDef, that message can be retrieved
3113
- * directly (this is always the case for frozen FieldDefs).
3114
- *
3115
- * If the field has not yet been added to a MessageDef, you can set the name
3116
- * of the containing type symbolically instead. This is mostly useful for
3117
- * extensions, where the extension is declared separately from the message. */
3118
- MessageDefPtr containing_type() const;
3119
-
3120
- /* The OneofDef to which this field belongs, or NULL if this field is not part
3121
- * of a oneof. */
3122
- OneofDefPtr containing_oneof() const;
3123
-
3124
- /* The field's type according to the enum in descriptor.proto. This is not
3125
- * the same as UPB_TYPE_*, because it distinguishes between (for example)
3126
- * INT32 and SINT32, whereas our "type" enum does not. This return of
3127
- * descriptor_type() is a function of type(), integer_format(), and
3128
- * is_tag_delimited(). */
3129
- DescriptorType descriptor_type() const {
3130
- return upb_fielddef_descriptortype(ptr_);
3131
- }
3132
-
3133
- /* Convenient field type tests. */
3134
- bool IsSubMessage() const { return upb_fielddef_issubmsg(ptr_); }
3135
- bool IsString() const { return upb_fielddef_isstring(ptr_); }
3136
- bool IsSequence() const { return upb_fielddef_isseq(ptr_); }
3137
- bool IsPrimitive() const { return upb_fielddef_isprimitive(ptr_); }
3138
- bool IsMap() const { return upb_fielddef_ismap(ptr_); }
3139
-
3140
- /* Returns the non-string default value for this fielddef, which may either
3141
- * be something the client set explicitly or the "default default" (0 for
3142
- * numbers, empty for strings). The field's type indicates the type of the
3143
- * returned value, except for enum fields that are still mutable.
3144
- *
3145
- * Requires that the given function matches the field's current type. */
3146
- int64_t default_int64() const { return upb_fielddef_defaultint64(ptr_); }
3147
- int32_t default_int32() const { return upb_fielddef_defaultint32(ptr_); }
3148
- uint64_t default_uint64() const { return upb_fielddef_defaultuint64(ptr_); }
3149
- uint32_t default_uint32() const { return upb_fielddef_defaultuint32(ptr_); }
3150
- bool default_bool() const { return upb_fielddef_defaultbool(ptr_); }
3151
- float default_float() const { return upb_fielddef_defaultfloat(ptr_); }
3152
- double default_double() const { return upb_fielddef_defaultdouble(ptr_); }
3153
-
3154
- /* The resulting string is always NULL-terminated. If non-NULL, the length
3155
- * will be stored in *len. */
3156
- const char *default_string(size_t * len) const {
3157
- return upb_fielddef_defaultstr(ptr_, len);
3158
- }
3159
-
3160
- /* Returns the enum or submessage def for this field, if any. The field's
3161
- * type must match (ie. you may only call enum_subdef() for fields where
3162
- * type() == UPB_TYPE_ENUM). */
3163
- EnumDefPtr enum_subdef() const;
3164
- MessageDefPtr message_subdef() const;
3165
-
3166
- private:
3167
- const upb_fielddef *ptr_;
3168
- };
3169
-
3170
- #endif /* __cplusplus */
3171
-
3172
3188
  /* upb_oneofdef ***************************************************************/
3173
3189
 
3174
- #ifdef __cplusplus
3175
- extern "C" {
3176
- #endif
3177
-
3178
3190
  typedef upb_inttable_iter upb_oneof_iter;
3179
3191
 
3180
3192
  const char *upb_oneofdef_name(const upb_oneofdef *o);
3181
3193
  const upb_msgdef *upb_oneofdef_containingtype(const upb_oneofdef *o);
3182
3194
  int upb_oneofdef_numfields(const upb_oneofdef *o);
3183
3195
  uint32_t upb_oneofdef_index(const upb_oneofdef *o);
3196
+ bool upb_oneofdef_issynthetic(const upb_oneofdef *o);
3184
3197
 
3185
3198
  /* Oneof lookups:
3186
3199
  * - ntof: look up a field by name.
@@ -3207,92 +3220,6 @@ void upb_oneof_iter_setdone(upb_oneof_iter *iter);
3207
3220
  bool upb_oneof_iter_isequal(const upb_oneof_iter *iter1,
3208
3221
  const upb_oneof_iter *iter2);
3209
3222
 
3210
- #ifdef __cplusplus
3211
- } /* extern "C" */
3212
-
3213
- /* Class that represents a oneof. */
3214
- class upb::OneofDefPtr {
3215
- public:
3216
- OneofDefPtr() : ptr_(nullptr) {}
3217
- explicit OneofDefPtr(const upb_oneofdef *ptr) : ptr_(ptr) {}
3218
-
3219
- const upb_oneofdef* ptr() const { return ptr_; }
3220
- explicit operator bool() { return ptr_ != nullptr; }
3221
-
3222
- /* Returns the MessageDef that owns this OneofDef. */
3223
- MessageDefPtr containing_type() const;
3224
-
3225
- /* Returns the name of this oneof. This is the name used to look up the oneof
3226
- * by name once added to a message def. */
3227
- const char* name() const { return upb_oneofdef_name(ptr_); }
3228
-
3229
- /* Returns the number of fields currently defined in the oneof. */
3230
- int field_count() const { return upb_oneofdef_numfields(ptr_); }
3231
-
3232
- /* Looks up by name. */
3233
- FieldDefPtr FindFieldByName(const char *name, size_t len) const {
3234
- return FieldDefPtr(upb_oneofdef_ntof(ptr_, name, len));
3235
- }
3236
- FieldDefPtr FindFieldByName(const char* name) const {
3237
- return FieldDefPtr(upb_oneofdef_ntofz(ptr_, name));
3238
- }
3239
-
3240
- template <class T>
3241
- FieldDefPtr FindFieldByName(const T& str) const {
3242
- return FindFieldByName(str.c_str(), str.size());
3243
- }
3244
-
3245
- /* Looks up by tag number. */
3246
- FieldDefPtr FindFieldByNumber(uint32_t num) const {
3247
- return FieldDefPtr(upb_oneofdef_itof(ptr_, num));
3248
- }
3249
-
3250
- class const_iterator
3251
- : public std::iterator<std::forward_iterator_tag, FieldDefPtr> {
3252
- public:
3253
- void operator++() { upb_oneof_next(&iter_); }
3254
-
3255
- FieldDefPtr operator*() const {
3256
- return FieldDefPtr(upb_oneof_iter_field(&iter_));
3257
- }
3258
-
3259
- bool operator!=(const const_iterator& other) const {
3260
- return !upb_oneof_iter_isequal(&iter_, &other.iter_);
3261
- }
3262
-
3263
- bool operator==(const const_iterator& other) const {
3264
- return upb_oneof_iter_isequal(&iter_, &other.iter_);
3265
- }
3266
-
3267
- private:
3268
- friend class OneofDefPtr;
3269
-
3270
- const_iterator() {}
3271
- explicit const_iterator(OneofDefPtr o) {
3272
- upb_oneof_begin(&iter_, o.ptr());
3273
- }
3274
- static const_iterator end() {
3275
- const_iterator iter;
3276
- upb_oneof_iter_setdone(&iter.iter_);
3277
- return iter;
3278
- }
3279
-
3280
- upb_oneof_iter iter_;
3281
- };
3282
-
3283
- const_iterator begin() const { return const_iterator(*this); }
3284
- const_iterator end() const { return const_iterator::end(); }
3285
-
3286
- private:
3287
- const upb_oneofdef *ptr_;
3288
- };
3289
-
3290
- inline upb::OneofDefPtr upb::FieldDefPtr::containing_oneof() const {
3291
- return OneofDefPtr(upb_fielddef_containingoneof(ptr_));
3292
- }
3293
-
3294
- #endif /* __cplusplus */
3295
-
3296
3223
  /* upb_msgdef *****************************************************************/
3297
3224
 
3298
3225
  typedef upb_inttable_iter upb_msg_field_iter;
@@ -3314,26 +3241,23 @@ typedef upb_strtable_iter upb_msg_oneof_iter;
3314
3241
  #define UPB_TIMESTAMP_SECONDS 1
3315
3242
  #define UPB_TIMESTAMP_NANOS 2
3316
3243
 
3317
- #ifdef __cplusplus
3318
- extern "C" {
3319
- #endif
3320
-
3321
3244
  const char *upb_msgdef_fullname(const upb_msgdef *m);
3322
3245
  const upb_filedef *upb_msgdef_file(const upb_msgdef *m);
3323
3246
  const char *upb_msgdef_name(const upb_msgdef *m);
3247
+ int upb_msgdef_numfields(const upb_msgdef *m);
3324
3248
  int upb_msgdef_numoneofs(const upb_msgdef *m);
3249
+ int upb_msgdef_numrealoneofs(const upb_msgdef *m);
3325
3250
  upb_syntax_t upb_msgdef_syntax(const upb_msgdef *m);
3326
3251
  bool upb_msgdef_mapentry(const upb_msgdef *m);
3327
3252
  upb_wellknowntype_t upb_msgdef_wellknowntype(const upb_msgdef *m);
3328
3253
  bool upb_msgdef_isnumberwrapper(const upb_msgdef *m);
3329
- bool upb_msgdef_setsyntax(upb_msgdef *m, upb_syntax_t syntax);
3330
3254
  const upb_fielddef *upb_msgdef_itof(const upb_msgdef *m, uint32_t i);
3331
3255
  const upb_fielddef *upb_msgdef_ntof(const upb_msgdef *m, const char *name,
3332
3256
  size_t len);
3333
3257
  const upb_oneofdef *upb_msgdef_ntoo(const upb_msgdef *m, const char *name,
3334
3258
  size_t len);
3335
- int upb_msgdef_numfields(const upb_msgdef *m);
3336
- int upb_msgdef_numoneofs(const upb_msgdef *m);
3259
+ const upb_msglayout *upb_msgdef_layout(const upb_msgdef *m);
3260
+ const upb_fielddef *_upb_msgdef_field(const upb_msgdef *m, int i);
3337
3261
 
3338
3262
  UPB_INLINE const upb_oneofdef *upb_msgdef_ntooz(const upb_msgdef *m,
3339
3263
  const char *name) {
@@ -3361,6 +3285,10 @@ UPB_INLINE bool upb_msgdef_lookupnamez(const upb_msgdef *m, const char *name,
3361
3285
  return upb_msgdef_lookupname(m, name, strlen(name), f, o);
3362
3286
  }
3363
3287
 
3288
+ /* Returns a field by either JSON name or regular proto name. */
3289
+ const upb_fielddef *upb_msgdef_lookupjsonname(const upb_msgdef *m,
3290
+ const char *name, size_t len);
3291
+
3364
3292
  /* Iteration over fields and oneofs. For example:
3365
3293
  *
3366
3294
  * upb_msg_field_iter i;
@@ -3392,194 +3320,6 @@ void upb_msg_oneof_iter_setdone(upb_msg_oneof_iter * iter);
3392
3320
  bool upb_msg_oneof_iter_isequal(const upb_msg_oneof_iter *iter1,
3393
3321
  const upb_msg_oneof_iter *iter2);
3394
3322
 
3395
- #ifdef __cplusplus
3396
- } /* extern "C" */
3397
-
3398
- /* Structure that describes a single .proto message type. */
3399
- class upb::MessageDefPtr {
3400
- public:
3401
- MessageDefPtr() : ptr_(nullptr) {}
3402
- explicit MessageDefPtr(const upb_msgdef *ptr) : ptr_(ptr) {}
3403
-
3404
- const upb_msgdef *ptr() const { return ptr_; }
3405
- explicit operator bool() const { return ptr_ != nullptr; }
3406
-
3407
- const char* full_name() const { return upb_msgdef_fullname(ptr_); }
3408
- const char* name() const { return upb_msgdef_name(ptr_); }
3409
-
3410
- /* The number of fields that belong to the MessageDef. */
3411
- int field_count() const { return upb_msgdef_numfields(ptr_); }
3412
-
3413
- /* The number of oneofs that belong to the MessageDef. */
3414
- int oneof_count() const { return upb_msgdef_numoneofs(ptr_); }
3415
-
3416
- upb_syntax_t syntax() const { return upb_msgdef_syntax(ptr_); }
3417
-
3418
- /* These return null pointers if the field is not found. */
3419
- FieldDefPtr FindFieldByNumber(uint32_t number) const {
3420
- return FieldDefPtr(upb_msgdef_itof(ptr_, number));
3421
- }
3422
- FieldDefPtr FindFieldByName(const char* name, size_t len) const {
3423
- return FieldDefPtr(upb_msgdef_ntof(ptr_, name, len));
3424
- }
3425
- FieldDefPtr FindFieldByName(const char *name) const {
3426
- return FieldDefPtr(upb_msgdef_ntofz(ptr_, name));
3427
- }
3428
-
3429
- template <class T>
3430
- FieldDefPtr FindFieldByName(const T& str) const {
3431
- return FindFieldByName(str.c_str(), str.size());
3432
- }
3433
-
3434
- OneofDefPtr FindOneofByName(const char* name, size_t len) const {
3435
- return OneofDefPtr(upb_msgdef_ntoo(ptr_, name, len));
3436
- }
3437
-
3438
- OneofDefPtr FindOneofByName(const char *name) const {
3439
- return OneofDefPtr(upb_msgdef_ntooz(ptr_, name));
3440
- }
3441
-
3442
- template <class T>
3443
- OneofDefPtr FindOneofByName(const T &str) const {
3444
- return FindOneofByName(str.c_str(), str.size());
3445
- }
3446
-
3447
- /* Is this message a map entry? */
3448
- bool mapentry() const { return upb_msgdef_mapentry(ptr_); }
3449
-
3450
- /* Return the type of well known type message. UPB_WELLKNOWN_UNSPECIFIED for
3451
- * non-well-known message. */
3452
- upb_wellknowntype_t wellknowntype() const {
3453
- return upb_msgdef_wellknowntype(ptr_);
3454
- }
3455
-
3456
- /* Whether is a number wrapper. */
3457
- bool isnumberwrapper() const { return upb_msgdef_isnumberwrapper(ptr_); }
3458
-
3459
- /* Iteration over fields. The order is undefined. */
3460
- class const_field_iterator
3461
- : public std::iterator<std::forward_iterator_tag, FieldDefPtr> {
3462
- public:
3463
- void operator++() { upb_msg_field_next(&iter_); }
3464
-
3465
- FieldDefPtr operator*() const {
3466
- return FieldDefPtr(upb_msg_iter_field(&iter_));
3467
- }
3468
-
3469
- bool operator!=(const const_field_iterator &other) const {
3470
- return !upb_msg_field_iter_isequal(&iter_, &other.iter_);
3471
- }
3472
-
3473
- bool operator==(const const_field_iterator &other) const {
3474
- return upb_msg_field_iter_isequal(&iter_, &other.iter_);
3475
- }
3476
-
3477
- private:
3478
- friend class MessageDefPtr;
3479
-
3480
- explicit const_field_iterator() {}
3481
-
3482
- explicit const_field_iterator(MessageDefPtr msg) {
3483
- upb_msg_field_begin(&iter_, msg.ptr());
3484
- }
3485
-
3486
- static const_field_iterator end() {
3487
- const_field_iterator iter;
3488
- upb_msg_field_iter_setdone(&iter.iter_);
3489
- return iter;
3490
- }
3491
-
3492
- upb_msg_field_iter iter_;
3493
- };
3494
-
3495
- /* Iteration over oneofs. The order is undefined. */
3496
- class const_oneof_iterator
3497
- : public std::iterator<std::forward_iterator_tag, OneofDefPtr> {
3498
- public:
3499
-
3500
- void operator++() { upb_msg_oneof_next(&iter_); }
3501
-
3502
- OneofDefPtr operator*() const {
3503
- return OneofDefPtr(upb_msg_iter_oneof(&iter_));
3504
- }
3505
-
3506
- bool operator!=(const const_oneof_iterator& other) const {
3507
- return !upb_msg_oneof_iter_isequal(&iter_, &other.iter_);
3508
- }
3509
-
3510
- bool operator==(const const_oneof_iterator &other) const {
3511
- return upb_msg_oneof_iter_isequal(&iter_, &other.iter_);
3512
- }
3513
-
3514
- private:
3515
- friend class MessageDefPtr;
3516
-
3517
- const_oneof_iterator() {}
3518
-
3519
- explicit const_oneof_iterator(MessageDefPtr msg) {
3520
- upb_msg_oneof_begin(&iter_, msg.ptr());
3521
- }
3522
-
3523
- static const_oneof_iterator end() {
3524
- const_oneof_iterator iter;
3525
- upb_msg_oneof_iter_setdone(&iter.iter_);
3526
- return iter;
3527
- }
3528
-
3529
- upb_msg_oneof_iter iter_;
3530
- };
3531
-
3532
- class ConstFieldAccessor {
3533
- public:
3534
- explicit ConstFieldAccessor(const upb_msgdef* md) : md_(md) {}
3535
- const_field_iterator begin() { return MessageDefPtr(md_).field_begin(); }
3536
- const_field_iterator end() { return MessageDefPtr(md_).field_end(); }
3537
- private:
3538
- const upb_msgdef* md_;
3539
- };
3540
-
3541
- class ConstOneofAccessor {
3542
- public:
3543
- explicit ConstOneofAccessor(const upb_msgdef* md) : md_(md) {}
3544
- const_oneof_iterator begin() { return MessageDefPtr(md_).oneof_begin(); }
3545
- const_oneof_iterator end() { return MessageDefPtr(md_).oneof_end(); }
3546
- private:
3547
- const upb_msgdef* md_;
3548
- };
3549
-
3550
- const_field_iterator field_begin() const {
3551
- return const_field_iterator(*this);
3552
- }
3553
-
3554
- const_field_iterator field_end() const { return const_field_iterator::end(); }
3555
-
3556
- const_oneof_iterator oneof_begin() const {
3557
- return const_oneof_iterator(*this);
3558
- }
3559
-
3560
- const_oneof_iterator oneof_end() const { return const_oneof_iterator::end(); }
3561
-
3562
- ConstFieldAccessor fields() const { return ConstFieldAccessor(ptr()); }
3563
- ConstOneofAccessor oneofs() const { return ConstOneofAccessor(ptr()); }
3564
-
3565
- private:
3566
- const upb_msgdef* ptr_;
3567
- };
3568
-
3569
- inline upb::MessageDefPtr upb::FieldDefPtr::message_subdef() const {
3570
- return MessageDefPtr(upb_fielddef_msgsubdef(ptr_));
3571
- }
3572
-
3573
- inline upb::MessageDefPtr upb::FieldDefPtr::containing_type() const {
3574
- return MessageDefPtr(upb_fielddef_containingtype(ptr_));
3575
- }
3576
-
3577
- inline upb::MessageDefPtr upb::OneofDefPtr::containing_type() const {
3578
- return MessageDefPtr(upb_oneofdef_containingtype(ptr_));
3579
- }
3580
-
3581
- #endif /* __cplusplus */
3582
-
3583
3323
  /* upb_enumdef ****************************************************************/
3584
3324
 
3585
3325
  typedef upb_strtable_iter upb_enum_iter;
@@ -3614,75 +3354,8 @@ bool upb_enum_done(upb_enum_iter *iter);
3614
3354
  const char *upb_enum_iter_name(upb_enum_iter *iter);
3615
3355
  int32_t upb_enum_iter_number(upb_enum_iter *iter);
3616
3356
 
3617
- #ifdef __cplusplus
3618
-
3619
- class upb::EnumDefPtr {
3620
- public:
3621
- EnumDefPtr() : ptr_(nullptr) {}
3622
- explicit EnumDefPtr(const upb_enumdef* ptr) : ptr_(ptr) {}
3623
-
3624
- const upb_enumdef* ptr() const { return ptr_; }
3625
- explicit operator bool() const { return ptr_ != nullptr; }
3626
-
3627
- const char* full_name() const { return upb_enumdef_fullname(ptr_); }
3628
- const char* name() const { return upb_enumdef_name(ptr_); }
3629
-
3630
- /* The value that is used as the default when no field default is specified.
3631
- * If not set explicitly, the first value that was added will be used.
3632
- * The default value must be a member of the enum.
3633
- * Requires that value_count() > 0. */
3634
- int32_t default_value() const { return upb_enumdef_default(ptr_); }
3635
-
3636
- /* Returns the number of values currently defined in the enum. Note that
3637
- * multiple names can refer to the same number, so this may be greater than
3638
- * the total number of unique numbers. */
3639
- int value_count() const { return upb_enumdef_numvals(ptr_); }
3640
-
3641
- /* Lookups from name to integer, returning true if found. */
3642
- bool FindValueByName(const char *name, int32_t *num) const {
3643
- return upb_enumdef_ntoiz(ptr_, name, num);
3644
- }
3645
-
3646
- /* Finds the name corresponding to the given number, or NULL if none was
3647
- * found. If more than one name corresponds to this number, returns the
3648
- * first one that was added. */
3649
- const char *FindValueByNumber(int32_t num) const {
3650
- return upb_enumdef_iton(ptr_, num);
3651
- }
3652
-
3653
- /* Iteration over name/value pairs. The order is undefined.
3654
- * Adding an enum val invalidates any iterators.
3655
- *
3656
- * TODO: make compatible with range-for, with elements as pairs? */
3657
- class Iterator {
3658
- public:
3659
- explicit Iterator(EnumDefPtr e) { upb_enum_begin(&iter_, e.ptr()); }
3660
-
3661
- int32_t number() { return upb_enum_iter_number(&iter_); }
3662
- const char *name() { return upb_enum_iter_name(&iter_); }
3663
- bool Done() { return upb_enum_done(&iter_); }
3664
- void Next() { return upb_enum_next(&iter_); }
3665
-
3666
- private:
3667
- upb_enum_iter iter_;
3668
- };
3669
-
3670
- private:
3671
- const upb_enumdef *ptr_;
3672
- };
3673
-
3674
- inline upb::EnumDefPtr upb::FieldDefPtr::enum_subdef() const {
3675
- return EnumDefPtr(upb_fielddef_enumsubdef(ptr_));
3676
- }
3677
-
3678
- #endif /* __cplusplus */
3679
-
3680
3357
  /* upb_filedef ****************************************************************/
3681
3358
 
3682
- #ifdef __cplusplus
3683
- extern "C" {
3684
- #endif
3685
-
3686
3359
  const char *upb_filedef_name(const upb_filedef *f);
3687
3360
  const char *upb_filedef_package(const upb_filedef *f);
3688
3361
  const char *upb_filedef_phpprefix(const upb_filedef *f);
@@ -3695,57 +3368,8 @@ const upb_filedef *upb_filedef_dep(const upb_filedef *f, int i);
3695
3368
  const upb_msgdef *upb_filedef_msg(const upb_filedef *f, int i);
3696
3369
  const upb_enumdef *upb_filedef_enum(const upb_filedef *f, int i);
3697
3370
 
3698
- #ifdef __cplusplus
3699
- } /* extern "C" */
3700
-
3701
- /* Class that represents a .proto file with some things defined in it.
3702
- *
3703
- * Many users won't care about FileDefs, but they are necessary if you want to
3704
- * read the values of file-level options. */
3705
- class upb::FileDefPtr {
3706
- public:
3707
- explicit FileDefPtr(const upb_filedef *ptr) : ptr_(ptr) {}
3708
-
3709
- const upb_filedef* ptr() const { return ptr_; }
3710
- explicit operator bool() const { return ptr_ != nullptr; }
3711
-
3712
- /* Get/set name of the file (eg. "foo/bar.proto"). */
3713
- const char* name() const { return upb_filedef_name(ptr_); }
3714
-
3715
- /* Package name for definitions inside the file (eg. "foo.bar"). */
3716
- const char* package() const { return upb_filedef_package(ptr_); }
3717
-
3718
- /* Sets the php class prefix which is prepended to all php generated classes
3719
- * from this .proto. Default is empty. */
3720
- const char* phpprefix() const { return upb_filedef_phpprefix(ptr_); }
3721
-
3722
- /* Use this option to change the namespace of php generated classes. Default
3723
- * is empty. When this option is empty, the package name will be used for
3724
- * determining the namespace. */
3725
- const char* phpnamespace() const { return upb_filedef_phpnamespace(ptr_); }
3726
-
3727
- /* Syntax for the file. Defaults to proto2. */
3728
- upb_syntax_t syntax() const { return upb_filedef_syntax(ptr_); }
3729
-
3730
- /* Get the list of dependencies from the file. These are returned in the
3731
- * order that they were added to the FileDefPtr. */
3732
- int dependency_count() const { return upb_filedef_depcount(ptr_); }
3733
- const FileDefPtr dependency(int index) const {
3734
- return FileDefPtr(upb_filedef_dep(ptr_, index));
3735
- }
3736
-
3737
- private:
3738
- const upb_filedef* ptr_;
3739
- };
3740
-
3741
- #endif /* __cplusplus */
3742
-
3743
3371
  /* upb_symtab *****************************************************************/
3744
3372
 
3745
- #ifdef __cplusplus
3746
- extern "C" {
3747
- #endif
3748
-
3749
3373
  upb_symtab *upb_symtab_new(void);
3750
3374
  void upb_symtab_free(upb_symtab* s);
3751
3375
  const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym);
@@ -3760,107 +3384,171 @@ const upb_filedef *upb_symtab_addfile(
3760
3384
 
3761
3385
  /* For generated code only: loads a generated descriptor. */
3762
3386
  typedef struct upb_def_init {
3763
- struct upb_def_init **deps;
3387
+ struct upb_def_init **deps; /* Dependencies of this file. */
3388
+ const upb_msglayout **layouts; /* Pre-order layouts of all messages. */
3764
3389
  const char *filename;
3765
- upb_strview descriptor;
3390
+ upb_strview descriptor; /* Serialized descriptor. */
3766
3391
  } upb_def_init;
3767
3392
 
3768
3393
  bool _upb_symtab_loaddefinit(upb_symtab *s, const upb_def_init *init);
3769
3394
 
3395
+
3770
3396
  #ifdef __cplusplus
3771
3397
  } /* extern "C" */
3398
+ #endif /* __cplusplus */
3772
3399
 
3773
- /* Non-const methods in upb::SymbolTable are NOT thread-safe. */
3774
- class upb::SymbolTable {
3775
- public:
3776
- SymbolTable() : ptr_(upb_symtab_new(), upb_symtab_free) {}
3777
- explicit SymbolTable(upb_symtab* s) : ptr_(s, upb_symtab_free) {}
3400
+ #endif /* UPB_DEF_H_ */
3778
3401
 
3779
- const upb_symtab* ptr() const { return ptr_.get(); }
3780
- upb_symtab* ptr() { return ptr_.get(); }
3402
+ #ifndef UPB_REFLECTION_H_
3403
+ #define UPB_REFLECTION_H_
3781
3404
 
3782
- /* Finds an entry in the symbol table with this exact name. If not found,
3783
- * returns NULL. */
3784
- MessageDefPtr LookupMessage(const char *sym) const {
3785
- return MessageDefPtr(upb_symtab_lookupmsg(ptr_.get(), sym));
3786
- }
3787
3405
 
3788
- EnumDefPtr LookupEnum(const char *sym) const {
3789
- return EnumDefPtr(upb_symtab_lookupenum(ptr_.get(), sym));
3790
- }
3791
3406
 
3792
- FileDefPtr LookupFile(const char *name) const {
3793
- return FileDefPtr(upb_symtab_lookupfile(ptr_.get(), name));
3794
- }
3407
+ typedef union {
3408
+ bool bool_val;
3409
+ float float_val;
3410
+ double double_val;
3411
+ int32_t int32_val;
3412
+ int64_t int64_val;
3413
+ uint32_t uint32_val;
3414
+ uint64_t uint64_val;
3415
+ const upb_map* map_val;
3416
+ const upb_msg* msg_val;
3417
+ const upb_array* array_val;
3418
+ upb_strview str_val;
3419
+ } upb_msgval;
3795
3420
 
3796
- /* TODO: iteration? */
3421
+ typedef union {
3422
+ upb_map* map;
3423
+ upb_msg* msg;
3424
+ upb_array* array;
3425
+ } upb_mutmsgval;
3797
3426
 
3798
- /* Adds the given serialized FileDescriptorProto to the pool. */
3799
- FileDefPtr AddFile(const google_protobuf_FileDescriptorProto *file_proto,
3800
- Status *status) {
3801
- return FileDefPtr(
3802
- upb_symtab_addfile(ptr_.get(), file_proto, status->ptr()));
3803
- }
3427
+ /** upb_msg *******************************************************************/
3804
3428
 
3805
- private:
3806
- std::unique_ptr<upb_symtab, decltype(&upb_symtab_free)> ptr_;
3807
- };
3429
+ /* Creates a new message of the given type in the given arena. */
3430
+ upb_msg *upb_msg_new(const upb_msgdef *m, upb_arena *a);
3808
3431
 
3809
- UPB_INLINE const char* upb_safecstr(const std::string& str) {
3810
- UPB_ASSERT(str.size() == std::strlen(str.c_str()));
3811
- return str.c_str();
3812
- }
3432
+ /* Returns the value associated with this field. */
3433
+ upb_msgval upb_msg_get(const upb_msg *msg, const upb_fielddef *f);
3813
3434
 
3814
- #endif /* __cplusplus */
3435
+ /* Returns a mutable pointer to a map, array, or submessage value. If the given
3436
+ * arena is non-NULL this will construct a new object if it was not previously
3437
+ * present. May not be called for primitive fields. */
3438
+ upb_mutmsgval upb_msg_mutable(upb_msg *msg, const upb_fielddef *f, upb_arena *a);
3815
3439
 
3440
+ /* May only be called for fields where upb_fielddef_haspresence(f) == true. */
3441
+ bool upb_msg_has(const upb_msg *msg, const upb_fielddef *f);
3816
3442
 
3817
- #endif /* UPB_DEF_H_ */
3443
+ /* Returns whether any field is set in the oneof. */
3444
+ bool upb_msg_hasoneof(const upb_msg *msg, const upb_oneofdef *o);
3445
+
3446
+ /* Sets the given field to the given value. For a msg/array/map/string, the
3447
+ * value must be in the same arena. */
3448
+ void upb_msg_set(upb_msg *msg, const upb_fielddef *f, upb_msgval val,
3449
+ upb_arena *a);
3818
3450
 
3451
+ /* Clears any field presence and sets the value back to its default. */
3452
+ void upb_msg_clearfield(upb_msg *msg, const upb_fielddef *f);
3819
3453
 
3820
- #ifndef UPB_MSGFACTORY_H_
3821
- #define UPB_MSGFACTORY_H_
3454
+ /* Iterate over present fields.
3455
+ *
3456
+ * size_t iter = UPB_MSG_BEGIN;
3457
+ * const upb_fielddef *f;
3458
+ * upb_msgval val;
3459
+ * while (upb_msg_next(msg, m, ext_pool, &f, &val, &iter)) {
3460
+ * process_field(f, val);
3461
+ * }
3462
+ *
3463
+ * If ext_pool is NULL, no extensions will be returned. If the given symtab
3464
+ * returns extensions that don't match what is in this message, those extensions
3465
+ * will be skipped.
3466
+ */
3822
3467
 
3823
- /** upb_msgfactory ************************************************************/
3468
+ #define UPB_MSG_BEGIN -1
3469
+ bool upb_msg_next(const upb_msg *msg, const upb_msgdef *m,
3470
+ const upb_symtab *ext_pool, const upb_fielddef **f,
3471
+ upb_msgval *val, size_t *iter);
3824
3472
 
3825
- struct upb_msgfactory;
3826
- typedef struct upb_msgfactory upb_msgfactory;
3473
+ /* Adds unknown data (serialized protobuf data) to the given message. The data
3474
+ * is copied into the message instance. */
3475
+ void upb_msg_addunknown(upb_msg *msg, const char *data, size_t len,
3476
+ upb_arena *arena);
3827
3477
 
3828
- #ifdef __cplusplus
3829
- extern "C" {
3830
- #endif
3478
+ /* Returns a reference to the message's unknown data. */
3479
+ const char *upb_msg_getunknown(const upb_msg *msg, size_t *len);
3831
3480
 
3832
- /* A upb_msgfactory contains a cache of upb_msglayout, upb_handlers, and
3833
- * upb_visitorplan objects. These are the objects necessary to represent,
3834
- * populate, and and visit upb_msg objects.
3835
- *
3836
- * These caches are all populated by upb_msgdef, and lazily created on demand.
3837
- */
3481
+ /** upb_array *****************************************************************/
3838
3482
 
3839
- /* Creates and destroys a msgfactory, respectively. The messages for this
3840
- * msgfactory must come from |symtab| (which should outlive the msgfactory). */
3841
- upb_msgfactory *upb_msgfactory_new(const upb_symtab *symtab);
3842
- void upb_msgfactory_free(upb_msgfactory *f);
3483
+ /* Creates a new array on the given arena that holds elements of this type. */
3484
+ upb_array *upb_array_new(upb_arena *a, upb_fieldtype_t type);
3843
3485
 
3844
- const upb_symtab *upb_msgfactory_symtab(const upb_msgfactory *f);
3486
+ /* Returns the size of the array. */
3487
+ size_t upb_array_size(const upb_array *arr);
3845
3488
 
3846
- /* The functions to get cached objects, lazily creating them on demand. These
3847
- * all require:
3848
- *
3849
- * - m is in upb_msgfactory_symtab(f)
3850
- * - upb_msgdef_mapentry(m) == false (since map messages can't have layouts).
3489
+ /* Returns the given element, which must be within the array's current size. */
3490
+ upb_msgval upb_array_get(const upb_array *arr, size_t i);
3491
+
3492
+ /* Sets the given element, which must be within the array's current size. */
3493
+ void upb_array_set(upb_array *arr, size_t i, upb_msgval val);
3494
+
3495
+ /* Appends an element to the array. Returns false on allocation failure. */
3496
+ bool upb_array_append(upb_array *array, upb_msgval val, upb_arena *arena);
3497
+
3498
+ /* Changes the size of a vector. New elements are initialized to empty/0.
3499
+ * Returns false on allocation failure. */
3500
+ bool upb_array_resize(upb_array *array, size_t size, upb_arena *arena);
3501
+
3502
+ /** upb_map *******************************************************************/
3503
+
3504
+ /* Creates a new map on the given arena with the given key/value size. */
3505
+ upb_map *upb_map_new(upb_arena *a, upb_fieldtype_t key_type,
3506
+ upb_fieldtype_t value_type);
3507
+
3508
+ /* Returns the number of entries in the map. */
3509
+ size_t upb_map_size(const upb_map *map);
3510
+
3511
+ /* Stores a value for the given key into |*val| (or the zero value if the key is
3512
+ * not present). Returns whether the key was present. The |val| pointer may be
3513
+ * NULL, in which case the function tests whether the given key is present. */
3514
+ bool upb_map_get(const upb_map *map, upb_msgval key, upb_msgval *val);
3515
+
3516
+ /* Removes all entries in the map. */
3517
+ void upb_map_clear(upb_map *map);
3518
+
3519
+ /* Sets the given key to the given value. Returns true if this was a new key in
3520
+ * the map, or false if an existing key was replaced. */
3521
+ bool upb_map_set(upb_map *map, upb_msgval key, upb_msgval val,
3522
+ upb_arena *arena);
3523
+
3524
+ /* Deletes this key from the table. Returns true if the key was present. */
3525
+ bool upb_map_delete(upb_map *map, upb_msgval key);
3526
+
3527
+ /* Map iteration:
3851
3528
  *
3852
- * The returned objects will live for as long as the msgfactory does.
3529
+ * size_t iter = UPB_MAP_BEGIN;
3530
+ * while (upb_mapiter_next(map, &iter)) {
3531
+ * upb_msgval key = upb_mapiter_key(map, iter);
3532
+ * upb_msgval val = upb_mapiter_value(map, iter);
3853
3533
  *
3854
- * TODO(haberman): consider making this thread-safe and take a const
3855
- * upb_msgfactory. */
3856
- const upb_msglayout *upb_msgfactory_getlayout(upb_msgfactory *f,
3857
- const upb_msgdef *m);
3534
+ * // If mutating is desired.
3535
+ * upb_mapiter_setvalue(map, iter, value2);
3536
+ * }
3537
+ */
3538
+
3539
+ /* Advances to the next entry. Returns false if no more entries are present. */
3540
+ bool upb_mapiter_next(const upb_map *map, size_t *iter);
3541
+
3542
+ /* Returns the key and value for this entry of the map. */
3543
+ upb_msgval upb_mapiter_key(const upb_map *map, size_t iter);
3544
+ upb_msgval upb_mapiter_value(const upb_map *map, size_t iter);
3545
+
3546
+ /* Sets the value for this entry. The iterator must not be done, and the
3547
+ * iterator must not have been initialized const. */
3548
+ void upb_mapiter_setvalue(upb_map *map, size_t iter, upb_msgval value);
3858
3549
 
3859
- #ifdef __cplusplus
3860
- } /* extern "C" */
3861
- #endif
3862
3550
 
3863
- #endif /* UPB_MSGFACTORY_H_ */
3551
+ #endif /* UPB_REFLECTION_H_ */
3864
3552
  /*
3865
3553
  ** upb::Handlers (upb_handlers)
3866
3554
  **
@@ -5693,15 +5381,16 @@ UPB_INLINE bool upb_sink_startsubmsg(upb_sink s, upb_selector_t sel,
5693
5381
  return sub->closure ? true : false;
5694
5382
  }
5695
5383
 
5696
- UPB_INLINE bool upb_sink_endsubmsg(upb_sink s, upb_selector_t sel) {
5384
+ UPB_INLINE bool upb_sink_endsubmsg(upb_sink s, upb_sink sub,
5385
+ upb_selector_t sel) {
5697
5386
  typedef upb_endfield_handlerfunc func;
5698
5387
  func *endsubmsg;
5699
5388
  const void *hd;
5700
5389
  if (!s.handlers) return true;
5701
5390
  endsubmsg = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
5702
5391
 
5703
- if (!endsubmsg) return s.closure;
5704
- return endsubmsg(s.closure, hd);
5392
+ if (!endsubmsg) return true;
5393
+ return endsubmsg(sub.closure, hd);
5705
5394
  }
5706
5395
 
5707
5396
  #ifdef __cplusplus
@@ -5867,8 +5556,8 @@ class upb::Sink {
5867
5556
  return ret;
5868
5557
  }
5869
5558
 
5870
- bool EndSubMessage(HandlersPtr::Selector s) {
5871
- return upb_sink_endsubmsg(sink_, s);
5559
+ bool EndSubMessage(HandlersPtr::Selector s, Sink sub) {
5560
+ return upb_sink_endsubmsg(sink_, sub.sink_, s);
5872
5561
  }
5873
5562
 
5874
5563
  /* For repeated fields of any type, the sequence of values must be wrapped in
@@ -6567,21 +6256,22 @@ extern "C" {
6567
6256
  * descriptor type (upb_descriptortype_t). */
6568
6257
  extern const uint8_t upb_pb_native_wire_types[];
6569
6258
 
6570
- UPB_INLINE uint64_t byteswap64(uint64_t val)
6571
- {
6572
- return ((((val) & 0xff00000000000000ull) >> 56)
6573
- | (((val) & 0x00ff000000000000ull) >> 40)
6574
- | (((val) & 0x0000ff0000000000ull) >> 24)
6575
- | (((val) & 0x000000ff00000000ull) >> 8)
6576
- | (((val) & 0x00000000ff000000ull) << 8)
6577
- | (((val) & 0x0000000000ff0000ull) << 24)
6578
- | (((val) & 0x000000000000ff00ull) << 40)
6579
- | (((val) & 0x00000000000000ffull) << 56));
6259
+ UPB_INLINE uint64_t byteswap64(uint64_t val) {
6260
+ uint64_t byte = 0xff;
6261
+ return (val & (byte << 56) >> 56)
6262
+ | (val & (byte << 48) >> 40)
6263
+ | (val & (byte << 40) >> 24)
6264
+ | (val & (byte << 32) >> 8)
6265
+ | (val & (byte << 24) << 8)
6266
+ | (val & (byte << 16) << 24)
6267
+ | (val & (byte << 8) << 40)
6268
+ | (val & (byte << 0) << 56);
6580
6269
  }
6581
6270
 
6582
6271
  /* Zig-zag encoding/decoding **************************************************/
6583
6272
 
6584
- UPB_INLINE int32_t upb_zzdec_32(uint32_t n) {
6273
+ UPB_INLINE int32_t upb_zzdec_32(uint64_t _n) {
6274
+ uint32_t n = (uint32_t)_n;
6585
6275
  return (n >> 1) ^ -(int32_t)(n & 1);
6586
6276
  }
6587
6277
  UPB_INLINE int64_t upb_zzdec_64(uint64_t n) {
@@ -7064,8 +6754,9 @@ class upb::json::PrinterPtr {
7064
6754
  #endif /* UPB_JSON_TYPED_PRINTER_H_ */
7065
6755
  /* See port_def.inc. This should #undef all macros #defined there. */
7066
6756
 
6757
+ #undef UPB_MAPTYPE_STRING
7067
6758
  #undef UPB_SIZE
7068
- #undef UPB_FIELD_AT
6759
+ #undef UPB_PTR_AT
7069
6760
  #undef UPB_READ_ONEOF
7070
6761
  #undef UPB_WRITE_ONEOF
7071
6762
  #undef UPB_INLINE
@@ -7075,6 +6766,7 @@ class upb::json::PrinterPtr {
7075
6766
  #undef UPB_MAX
7076
6767
  #undef UPB_MIN
7077
6768
  #undef UPB_UNUSED
6769
+ #undef UPB_ASSUME
7078
6770
  #undef UPB_ASSERT
7079
6771
  #undef UPB_ASSERT_DEBUGVAR
7080
6772
  #undef UPB_UNREACHABLE