google-protobuf 4.29.0.rc.2-aarch64-linux → 4.29.0.rc.3-aarch64-linux

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1133,16 +1133,47 @@ UPB_FORCEINLINE bool upb_EpsCopyInputStream_TryParseDelimitedFast(
1133
1133
  #ifndef UPB_JSON_DECODE_H_
1134
1134
  #define UPB_JSON_DECODE_H_
1135
1135
 
1136
+ #include <stddef.h>
1136
1137
 
1137
- #ifndef UPB_REFLECTION_DEF_H_
1138
- #define UPB_REFLECTION_DEF_H_
1139
1138
 
1140
- // IWYU pragma: begin_exports
1139
+ // Public APIs for message operations that do not depend on the schema.
1140
+ //
1141
+ // MiniTable-based accessors live in accessors.h.
1141
1142
 
1142
- // IWYU pragma: private, include "upb/reflection/def.h"
1143
+ #ifndef UPB_MESSAGE_MESSAGE_H_
1144
+ #define UPB_MESSAGE_MESSAGE_H_
1143
1145
 
1144
- #ifndef UPB_REFLECTION_DEF_POOL_H_
1145
- #define UPB_REFLECTION_DEF_POOL_H_
1146
+ #include <stddef.h>
1147
+
1148
+
1149
+ /*
1150
+ ** Our memory representation for parsing tables and messages themselves.
1151
+ ** Functions in this file are used by generated code and possibly reflection.
1152
+ **
1153
+ ** The definitions in this file are internal to upb.
1154
+ **/
1155
+
1156
+ #ifndef UPB_MESSAGE_INTERNAL_MESSAGE_H_
1157
+ #define UPB_MESSAGE_INTERNAL_MESSAGE_H_
1158
+
1159
+ #include <stdlib.h>
1160
+ #include <string.h>
1161
+
1162
+
1163
+ #ifndef UPB_MESSAGE_INTERNAL_EXTENSION_H_
1164
+ #define UPB_MESSAGE_INTERNAL_EXTENSION_H_
1165
+
1166
+ #include <stddef.h>
1167
+
1168
+
1169
+ // Users should include array.h or map.h instead.
1170
+ // IWYU pragma: private, include "upb/message/array.h"
1171
+
1172
+ #ifndef UPB_MESSAGE_VALUE_H_
1173
+ #define UPB_MESSAGE_VALUE_H_
1174
+
1175
+ #include <stdint.h>
1176
+ #include <string.h>
1146
1177
 
1147
1178
  #ifndef UPB_BASE_STRING_VIEW_H_
1148
1179
  #define UPB_BASE_STRING_VIEW_H_
@@ -1196,74 +1227,63 @@ UPB_INLINE bool upb_StringView_IsEqual(upb_StringView a, upb_StringView b) {
1196
1227
 
1197
1228
  #endif /* UPB_BASE_STRING_VIEW_H_ */
1198
1229
 
1199
- // IWYU pragma: private, include "upb/reflection/def.h"
1200
-
1201
- // Declarations common to all public def types.
1202
-
1203
- #ifndef UPB_REFLECTION_COMMON_H_
1204
- #define UPB_REFLECTION_COMMON_H_
1205
-
1206
- #ifndef THIRD_PARTY_UPB_UPB_REFLECTION_DESCRIPTOR_BOOTSTRAP_H_
1207
- #define THIRD_PARTY_UPB_UPB_REFLECTION_DESCRIPTOR_BOOTSTRAP_H_
1208
-
1209
- // IWYU pragma: begin_exports
1210
-
1211
- #if defined(UPB_BOOTSTRAP_STAGE) && UPB_BOOTSTRAP_STAGE == 0
1212
- // This header is checked in.
1213
- #elif UPB_BOOTSTRAP_STAGE == 1
1214
- // This header is generated at build time by the bootstrapping process.
1215
- #else
1216
- // This is the normal header, generated by upb_c_proto_library().
1217
- /* This file was generated by upb_generator from the input file:
1218
- *
1219
- * google/protobuf/descriptor.proto
1220
- *
1221
- * Do not edit -- your changes will be discarded when the file is
1222
- * regenerated.
1223
- * NO CHECKED-IN PROTOBUF GENCODE */
1224
-
1225
- #ifndef GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H__UPB_H_
1226
- #define GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H__UPB_H_
1230
+ // Must be last.
1227
1231
 
1232
+ #ifdef __cplusplus
1233
+ extern "C" {
1234
+ #endif
1228
1235
 
1229
- #ifndef UPB_GENERATED_CODE_SUPPORT_H_
1230
- #define UPB_GENERATED_CODE_SUPPORT_H_
1236
+ typedef union {
1237
+ bool bool_val;
1238
+ float float_val;
1239
+ double double_val;
1240
+ int32_t int32_val;
1241
+ int64_t int64_val;
1242
+ uint32_t uint32_val;
1243
+ uint64_t uint64_val;
1244
+ const struct upb_Array* array_val;
1245
+ const struct upb_Map* map_val;
1246
+ const struct upb_Message* msg_val;
1247
+ upb_StringView str_val;
1231
1248
 
1232
- // IWYU pragma: begin_exports
1249
+ // EXPERIMENTAL: A tagged upb_Message*. Users must use this instead of
1250
+ // msg_val if unlinked sub-messages may possibly be in use. See the
1251
+ // documentation in kUpb_DecodeOption_ExperimentalAllowUnlinked for more
1252
+ // information.
1253
+ uintptr_t tagged_msg_val; // upb_TaggedMessagePtr
1254
+ } upb_MessageValue;
1233
1255
 
1234
- #ifndef UPB_BASE_UPCAST_H_
1235
- #define UPB_BASE_UPCAST_H_
1256
+ UPB_API_INLINE upb_MessageValue upb_MessageValue_Zero(void) {
1257
+ upb_MessageValue zero;
1258
+ memset(&zero, 0, sizeof(zero));
1259
+ return zero;
1260
+ }
1236
1261
 
1237
- // Must be last.
1262
+ typedef union {
1263
+ struct upb_Array* array;
1264
+ struct upb_Map* map;
1265
+ struct upb_Message* msg;
1266
+ } upb_MutableMessageValue;
1238
1267
 
1239
- // This macro provides a way to upcast message pointers in a way that is
1240
- // somewhat more bulletproof than blindly casting a pointer. Example:
1241
- //
1242
- // typedef struct {
1243
- // upb_Message UPB_PRIVATE(base);
1244
- // } pkg_FooMessage;
1245
- //
1246
- // void f(pkg_FooMessage* msg) {
1247
- // upb_Decode(UPB_UPCAST(msg), ...);
1248
- // }
1268
+ UPB_API_INLINE upb_MutableMessageValue upb_MutableMessageValue_Zero(void) {
1269
+ upb_MutableMessageValue zero;
1270
+ memset(&zero, 0, sizeof(zero));
1271
+ return zero;
1272
+ }
1249
1273
 
1250
- #define UPB_UPCAST(x) (&(x)->base##_dont_copy_me__upb_internal_use_only)
1274
+ #ifdef __cplusplus
1275
+ } /* extern "C" */
1276
+ #endif
1251
1277
 
1252
1278
 
1253
- #endif /* UPB_BASE_UPCAST_H_ */
1279
+ #endif /* UPB_MESSAGE_VALUE_H_ */
1254
1280
 
1255
- #ifndef UPB_MESSAGE_ACCESSORS_H_
1256
- #define UPB_MESSAGE_ACCESSORS_H_
1281
+ #ifndef UPB_MINI_TABLE_EXTENSION_H_
1282
+ #define UPB_MINI_TABLE_EXTENSION_H_
1257
1283
 
1258
1284
  #include <stdint.h>
1259
1285
 
1260
1286
 
1261
- #ifndef UPB_MESSAGE_ARRAY_H_
1262
- #define UPB_MESSAGE_ARRAY_H_
1263
-
1264
- #include <stddef.h>
1265
-
1266
-
1267
1287
  #ifndef UPB_BASE_DESCRIPTOR_CONSTANTS_H_
1268
1288
  #define UPB_BASE_DESCRIPTOR_CONSTANTS_H_
1269
1289
 
@@ -1367,290 +1387,94 @@ UPB_INLINE bool upb_FieldType_IsPackable(upb_FieldType field_type) {
1367
1387
 
1368
1388
  #endif /* UPB_BASE_DESCRIPTOR_CONSTANTS_H_ */
1369
1389
 
1370
- #ifndef UPB_MESSAGE_INTERNAL_ARRAY_H_
1371
- #define UPB_MESSAGE_INTERNAL_ARRAY_H_
1390
+ #ifndef UPB_MINI_TABLE_INTERNAL_EXTENSION_H_
1391
+ #define UPB_MINI_TABLE_INTERNAL_EXTENSION_H_
1372
1392
 
1393
+ #include <stddef.h>
1373
1394
  #include <stdint.h>
1374
- #include <string.h>
1375
1395
 
1376
1396
 
1377
- // Must be last.
1397
+ #ifndef UPB_MINI_TABLE_INTERNAL_FIELD_H_
1398
+ #define UPB_MINI_TABLE_INTERNAL_FIELD_H_
1378
1399
 
1379
- #define _UPB_ARRAY_MASK_IMM 0x4 // Frozen/immutable bit.
1380
- #define _UPB_ARRAY_MASK_LG2 0x3 // Encoded elem size.
1381
- #define _UPB_ARRAY_MASK_ALL (_UPB_ARRAY_MASK_IMM | _UPB_ARRAY_MASK_LG2)
1400
+ #include <stddef.h>
1401
+ #include <stdint.h>
1402
+
1403
+
1404
+ #ifndef UPB_MINI_TABLE_INTERNAL_SIZE_LOG2_H_
1405
+ #define UPB_MINI_TABLE_INTERNAL_SIZE_LOG2_H_
1406
+
1407
+ #include <stddef.h>
1408
+ #include <stdint.h>
1409
+
1410
+
1411
+ // Must be last.
1382
1412
 
1383
1413
  #ifdef __cplusplus
1384
1414
  extern "C" {
1385
1415
  #endif
1386
1416
 
1387
- // LINT.IfChange(upb_Array)
1417
+ // Return the log2 of the storage size in bytes for a upb_CType
1418
+ UPB_INLINE int UPB_PRIVATE(_upb_CType_SizeLg2)(upb_CType c_type) {
1419
+ static const int8_t size[] = {
1420
+ 0, // kUpb_CType_Bool
1421
+ 2, // kUpb_CType_Float
1422
+ 2, // kUpb_CType_Int32
1423
+ 2, // kUpb_CType_UInt32
1424
+ 2, // kUpb_CType_Enum
1425
+ UPB_SIZE(2, 3), // kUpb_CType_Message
1426
+ 3, // kUpb_CType_Double
1427
+ 3, // kUpb_CType_Int64
1428
+ 3, // kUpb_CType_UInt64
1429
+ UPB_SIZE(3, 4), // kUpb_CType_String
1430
+ UPB_SIZE(3, 4), // kUpb_CType_Bytes
1431
+ };
1388
1432
 
1389
- // Our internal representation for repeated fields.
1390
- struct upb_Array {
1391
- // This is a tagged pointer. Bits #0 and #1 encode the elem size as follows:
1392
- // 0 maps to elem size 1
1393
- // 1 maps to elem size 4
1394
- // 2 maps to elem size 8
1395
- // 3 maps to elem size 16
1396
- //
1397
- // Bit #2 contains the frozen/immutable flag.
1398
- uintptr_t UPB_ONLYBITS(data);
1433
+ // -1 here because the enum is one-based but the table is zero-based.
1434
+ return size[c_type - 1];
1435
+ }
1399
1436
 
1400
- size_t UPB_ONLYBITS(size); // The number of elements in the array.
1401
- size_t UPB_PRIVATE(capacity); // Allocated storage. Measured in elements.
1402
- };
1437
+ // Return the log2 of the storage size in bytes for a upb_FieldType
1438
+ UPB_INLINE int UPB_PRIVATE(_upb_FieldType_SizeLg2)(upb_FieldType field_type) {
1439
+ static const int8_t size[] = {
1440
+ 3, // kUpb_FieldType_Double
1441
+ 2, // kUpb_FieldType_Float
1442
+ 3, // kUpb_FieldType_Int64
1443
+ 3, // kUpb_FieldType_UInt64
1444
+ 2, // kUpb_FieldType_Int32
1445
+ 3, // kUpb_FieldType_Fixed64
1446
+ 2, // kUpb_FieldType_Fixed32
1447
+ 0, // kUpb_FieldType_Bool
1448
+ UPB_SIZE(3, 4), // kUpb_FieldType_String
1449
+ UPB_SIZE(2, 3), // kUpb_FieldType_Group
1450
+ UPB_SIZE(2, 3), // kUpb_FieldType_Message
1451
+ UPB_SIZE(3, 4), // kUpb_FieldType_Bytes
1452
+ 2, // kUpb_FieldType_UInt32
1453
+ 2, // kUpb_FieldType_Enum
1454
+ 2, // kUpb_FieldType_SFixed32
1455
+ 3, // kUpb_FieldType_SFixed64
1456
+ 2, // kUpb_FieldType_SInt32
1457
+ 3, // kUpb_FieldType_SInt64
1458
+ };
1403
1459
 
1404
- UPB_INLINE void UPB_PRIVATE(_upb_Array_ShallowFreeze)(struct upb_Array* arr) {
1405
- arr->UPB_ONLYBITS(data) |= _UPB_ARRAY_MASK_IMM;
1460
+ // -1 here because the enum is one-based but the table is zero-based.
1461
+ return size[field_type - 1];
1406
1462
  }
1407
1463
 
1408
- UPB_API_INLINE bool upb_Array_IsFrozen(const struct upb_Array* arr) {
1409
- return (arr->UPB_ONLYBITS(data) & _UPB_ARRAY_MASK_IMM) != 0;
1410
- }
1464
+ #ifdef __cplusplus
1465
+ } /* extern "C" */
1466
+ #endif
1411
1467
 
1412
- UPB_INLINE void UPB_PRIVATE(_upb_Array_SetTaggedPtr)(struct upb_Array* array,
1413
- void* data, size_t lg2) {
1414
- UPB_ASSERT(lg2 != 1);
1415
- UPB_ASSERT(lg2 <= 4);
1416
- const size_t bits = lg2 - (lg2 != 0);
1417
- array->UPB_ONLYBITS(data) = (uintptr_t)data | bits;
1418
- }
1419
1468
 
1420
- UPB_INLINE size_t
1421
- UPB_PRIVATE(_upb_Array_ElemSizeLg2)(const struct upb_Array* array) {
1422
- const size_t bits = array->UPB_ONLYBITS(data) & _UPB_ARRAY_MASK_LG2;
1423
- const size_t lg2 = bits + (bits != 0);
1424
- return lg2;
1425
- }
1469
+ #endif /* UPB_MINI_TABLE_INTERNAL_SIZE_LOG2_H_ */
1426
1470
 
1427
- UPB_API_INLINE const void* upb_Array_DataPtr(const struct upb_Array* array) {
1428
- UPB_PRIVATE(_upb_Array_ElemSizeLg2)(array); // Check assertions.
1429
- return (void*)(array->UPB_ONLYBITS(data) & ~(uintptr_t)_UPB_ARRAY_MASK_ALL);
1430
- }
1471
+ // Must be last.
1431
1472
 
1432
- UPB_API_INLINE void* upb_Array_MutableDataPtr(struct upb_Array* array) {
1433
- return (void*)upb_Array_DataPtr(array);
1434
- }
1435
-
1436
- UPB_INLINE struct upb_Array* UPB_PRIVATE(_upb_Array_New)(upb_Arena* arena,
1437
- size_t init_capacity,
1438
- int elem_size_lg2) {
1439
- UPB_ASSERT(elem_size_lg2 != 1);
1440
- UPB_ASSERT(elem_size_lg2 <= 4);
1441
- const size_t array_size =
1442
- UPB_ALIGN_UP(sizeof(struct upb_Array), UPB_MALLOC_ALIGN);
1443
- const size_t bytes = array_size + (init_capacity << elem_size_lg2);
1444
- struct upb_Array* array = (struct upb_Array*)upb_Arena_Malloc(arena, bytes);
1445
- if (!array) return NULL;
1446
- UPB_PRIVATE(_upb_Array_SetTaggedPtr)
1447
- (array, UPB_PTR_AT(array, array_size, void), elem_size_lg2);
1448
- array->UPB_ONLYBITS(size) = 0;
1449
- array->UPB_PRIVATE(capacity) = init_capacity;
1450
- return array;
1451
- }
1452
-
1453
- // Resizes the capacity of the array to be at least min_size.
1454
- bool UPB_PRIVATE(_upb_Array_Realloc)(struct upb_Array* array, size_t min_size,
1455
- upb_Arena* arena);
1456
-
1457
- UPB_API_INLINE bool upb_Array_Reserve(struct upb_Array* array, size_t size,
1458
- upb_Arena* arena) {
1459
- UPB_ASSERT(!upb_Array_IsFrozen(array));
1460
- if (array->UPB_PRIVATE(capacity) < size)
1461
- return UPB_PRIVATE(_upb_Array_Realloc)(array, size, arena);
1462
- return true;
1463
- }
1464
-
1465
- // Resize without initializing new elements.
1466
- UPB_INLINE bool UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
1467
- struct upb_Array* array, size_t size, upb_Arena* arena) {
1468
- UPB_ASSERT(!upb_Array_IsFrozen(array));
1469
- UPB_ASSERT(size <= array->UPB_ONLYBITS(size) ||
1470
- arena); // Allow NULL arena when shrinking.
1471
- if (!upb_Array_Reserve(array, size, arena)) return false;
1472
- array->UPB_ONLYBITS(size) = size;
1473
- return true;
1474
- }
1475
-
1476
- // This function is intended for situations where elem_size is compile-time
1477
- // constant or a known expression of the form (1 << lg2), so that the expression
1478
- // i*elem_size does not result in an actual multiplication.
1479
- UPB_INLINE void UPB_PRIVATE(_upb_Array_Set)(struct upb_Array* array, size_t i,
1480
- const void* data,
1481
- size_t elem_size) {
1482
- UPB_ASSERT(!upb_Array_IsFrozen(array));
1483
- UPB_ASSERT(i < array->UPB_ONLYBITS(size));
1484
- UPB_ASSERT(elem_size == 1U << UPB_PRIVATE(_upb_Array_ElemSizeLg2)(array));
1485
- char* arr_data = (char*)upb_Array_MutableDataPtr(array);
1486
- memcpy(arr_data + (i * elem_size), data, elem_size);
1487
- }
1488
-
1489
- UPB_API_INLINE size_t upb_Array_Size(const struct upb_Array* arr) {
1490
- return arr->UPB_ONLYBITS(size);
1491
- }
1492
-
1493
- // LINT.ThenChange(GoogleInternalName0)
1494
-
1495
- #ifdef __cplusplus
1496
- } /* extern "C" */
1497
- #endif
1498
-
1499
- #undef _UPB_ARRAY_MASK_IMM
1500
- #undef _UPB_ARRAY_MASK_LG2
1501
- #undef _UPB_ARRAY_MASK_ALL
1502
-
1503
-
1504
- #endif /* UPB_MESSAGE_INTERNAL_ARRAY_H_ */
1505
-
1506
- // Users should include array.h or map.h instead.
1507
- // IWYU pragma: private, include "upb/message/array.h"
1508
-
1509
- #ifndef UPB_MESSAGE_VALUE_H_
1510
- #define UPB_MESSAGE_VALUE_H_
1511
-
1512
- #include <stdint.h>
1513
- #include <string.h>
1514
-
1515
-
1516
- // Must be last.
1517
-
1518
- #ifdef __cplusplus
1519
- extern "C" {
1520
- #endif
1521
-
1522
- typedef union {
1523
- bool bool_val;
1524
- float float_val;
1525
- double double_val;
1526
- int32_t int32_val;
1527
- int64_t int64_val;
1528
- uint32_t uint32_val;
1529
- uint64_t uint64_val;
1530
- const struct upb_Array* array_val;
1531
- const struct upb_Map* map_val;
1532
- const struct upb_Message* msg_val;
1533
- upb_StringView str_val;
1534
-
1535
- // EXPERIMENTAL: A tagged upb_Message*. Users must use this instead of
1536
- // msg_val if unlinked sub-messages may possibly be in use. See the
1537
- // documentation in kUpb_DecodeOption_ExperimentalAllowUnlinked for more
1538
- // information.
1539
- uintptr_t tagged_msg_val; // upb_TaggedMessagePtr
1540
- } upb_MessageValue;
1541
-
1542
- UPB_API_INLINE upb_MessageValue upb_MessageValue_Zero(void) {
1543
- upb_MessageValue zero;
1544
- memset(&zero, 0, sizeof(zero));
1545
- return zero;
1546
- }
1547
-
1548
- typedef union {
1549
- struct upb_Array* array;
1550
- struct upb_Map* map;
1551
- struct upb_Message* msg;
1552
- } upb_MutableMessageValue;
1553
-
1554
- UPB_API_INLINE upb_MutableMessageValue upb_MutableMessageValue_Zero(void) {
1555
- upb_MutableMessageValue zero;
1556
- memset(&zero, 0, sizeof(zero));
1557
- return zero;
1558
- }
1559
-
1560
- #ifdef __cplusplus
1561
- } /* extern "C" */
1562
- #endif
1563
-
1564
-
1565
- #endif /* UPB_MESSAGE_VALUE_H_ */
1566
-
1567
- #ifndef UPB_MINI_TABLE_FIELD_H_
1568
- #define UPB_MINI_TABLE_FIELD_H_
1569
-
1570
- #include <stdint.h>
1571
-
1572
-
1573
- #ifndef UPB_MINI_TABLE_INTERNAL_FIELD_H_
1574
- #define UPB_MINI_TABLE_INTERNAL_FIELD_H_
1575
-
1576
- #include <stddef.h>
1577
- #include <stdint.h>
1578
-
1579
-
1580
- #ifndef UPB_MINI_TABLE_INTERNAL_SIZE_LOG2_H_
1581
- #define UPB_MINI_TABLE_INTERNAL_SIZE_LOG2_H_
1582
-
1583
- #include <stddef.h>
1584
- #include <stdint.h>
1585
-
1586
-
1587
- // Must be last.
1588
-
1589
- #ifdef __cplusplus
1590
- extern "C" {
1591
- #endif
1592
-
1593
- // Return the log2 of the storage size in bytes for a upb_CType
1594
- UPB_INLINE int UPB_PRIVATE(_upb_CType_SizeLg2)(upb_CType c_type) {
1595
- static const int8_t size[] = {
1596
- 0, // kUpb_CType_Bool
1597
- 2, // kUpb_CType_Float
1598
- 2, // kUpb_CType_Int32
1599
- 2, // kUpb_CType_UInt32
1600
- 2, // kUpb_CType_Enum
1601
- UPB_SIZE(2, 3), // kUpb_CType_Message
1602
- 3, // kUpb_CType_Double
1603
- 3, // kUpb_CType_Int64
1604
- 3, // kUpb_CType_UInt64
1605
- UPB_SIZE(3, 4), // kUpb_CType_String
1606
- UPB_SIZE(3, 4), // kUpb_CType_Bytes
1607
- };
1608
-
1609
- // -1 here because the enum is one-based but the table is zero-based.
1610
- return size[c_type - 1];
1611
- }
1612
-
1613
- // Return the log2 of the storage size in bytes for a upb_FieldType
1614
- UPB_INLINE int UPB_PRIVATE(_upb_FieldType_SizeLg2)(upb_FieldType field_type) {
1615
- static const int8_t size[] = {
1616
- 3, // kUpb_FieldType_Double
1617
- 2, // kUpb_FieldType_Float
1618
- 3, // kUpb_FieldType_Int64
1619
- 3, // kUpb_FieldType_UInt64
1620
- 2, // kUpb_FieldType_Int32
1621
- 3, // kUpb_FieldType_Fixed64
1622
- 2, // kUpb_FieldType_Fixed32
1623
- 0, // kUpb_FieldType_Bool
1624
- UPB_SIZE(3, 4), // kUpb_FieldType_String
1625
- UPB_SIZE(2, 3), // kUpb_FieldType_Group
1626
- UPB_SIZE(2, 3), // kUpb_FieldType_Message
1627
- UPB_SIZE(3, 4), // kUpb_FieldType_Bytes
1628
- 2, // kUpb_FieldType_UInt32
1629
- 2, // kUpb_FieldType_Enum
1630
- 2, // kUpb_FieldType_SFixed32
1631
- 3, // kUpb_FieldType_SFixed64
1632
- 2, // kUpb_FieldType_SInt32
1633
- 3, // kUpb_FieldType_SInt64
1634
- };
1635
-
1636
- // -1 here because the enum is one-based but the table is zero-based.
1637
- return size[field_type - 1];
1638
- }
1639
-
1640
- #ifdef __cplusplus
1641
- } /* extern "C" */
1642
- #endif
1643
-
1644
-
1645
- #endif /* UPB_MINI_TABLE_INTERNAL_SIZE_LOG2_H_ */
1646
-
1647
- // Must be last.
1648
-
1649
- // LINT.IfChange(struct_definition)
1650
- struct upb_MiniTableField {
1651
- uint32_t UPB_ONLYBITS(number);
1652
- uint16_t UPB_ONLYBITS(offset);
1653
- int16_t presence; // If >0, hasbit_index. If <0, ~oneof_index
1473
+ // LINT.IfChange(struct_definition)
1474
+ struct upb_MiniTableField {
1475
+ uint32_t UPB_ONLYBITS(number);
1476
+ uint16_t UPB_ONLYBITS(offset);
1477
+ int16_t presence; // If >0, hasbit_index. If <0, ~oneof_index
1654
1478
 
1655
1479
  // Indexes into `upb_MiniTable.subs`
1656
1480
  // Will be set to `kUpb_NoSub` if `descriptortype` != MESSAGE/GROUP/ENUM
@@ -1850,47 +1674,104 @@ UPB_INLINE size_t UPB_PRIVATE(_upb_MiniTableField_ElemSizeLg2)(
1850
1674
 
1851
1675
  #endif /* UPB_MINI_TABLE_INTERNAL_FIELD_H_ */
1852
1676
 
1677
+ #ifndef UPB_MINI_TABLE_INTERNAL_SUB_H_
1678
+ #define UPB_MINI_TABLE_INTERNAL_SUB_H_
1679
+
1853
1680
  // Must be last.
1854
1681
 
1855
- typedef struct upb_MiniTableField upb_MiniTableField;
1682
+ typedef union {
1683
+ const struct upb_MiniTable* const* UPB_PRIVATE(submsg);
1684
+ const struct upb_MiniTableEnum* UPB_PRIVATE(subenum);
1685
+ } upb_MiniTableSubInternal;
1686
+
1687
+ union upb_MiniTableSub {
1688
+ const struct upb_MiniTable* UPB_PRIVATE(submsg);
1689
+ const struct upb_MiniTableEnum* UPB_PRIVATE(subenum);
1690
+ };
1856
1691
 
1857
1692
  #ifdef __cplusplus
1858
1693
  extern "C" {
1859
1694
  #endif
1860
1695
 
1861
- UPB_API_INLINE upb_CType upb_MiniTableField_CType(const upb_MiniTableField* f);
1696
+ UPB_API_INLINE union upb_MiniTableSub upb_MiniTableSub_FromEnum(
1697
+ const struct upb_MiniTableEnum* subenum) {
1698
+ union upb_MiniTableSub out;
1699
+ out.UPB_PRIVATE(subenum) = subenum;
1700
+ return out;
1701
+ }
1862
1702
 
1863
- UPB_API_INLINE bool upb_MiniTableField_HasPresence(const upb_MiniTableField* f);
1703
+ UPB_API_INLINE union upb_MiniTableSub upb_MiniTableSub_FromMessage(
1704
+ const struct upb_MiniTable* submsg) {
1705
+ union upb_MiniTableSub out;
1706
+ out.UPB_PRIVATE(submsg) = submsg;
1707
+ return out;
1708
+ }
1864
1709
 
1865
- UPB_API_INLINE bool upb_MiniTableField_IsArray(const upb_MiniTableField* f);
1710
+ UPB_API_INLINE const struct upb_MiniTableEnum* upb_MiniTableSub_Enum(
1711
+ const union upb_MiniTableSub sub) {
1712
+ return sub.UPB_PRIVATE(subenum);
1713
+ }
1866
1714
 
1867
- UPB_API_INLINE bool upb_MiniTableField_IsClosedEnum(
1868
- const upb_MiniTableField* f);
1715
+ UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableSub_Message(
1716
+ const union upb_MiniTableSub sub) {
1717
+ return sub.UPB_PRIVATE(submsg);
1718
+ }
1869
1719
 
1870
- UPB_API_INLINE bool upb_MiniTableField_IsExtension(const upb_MiniTableField* f);
1720
+ #ifdef __cplusplus
1721
+ } /* extern "C" */
1722
+ #endif
1871
1723
 
1872
- UPB_API_INLINE bool upb_MiniTableField_IsInOneof(const upb_MiniTableField* f);
1873
1724
 
1874
- UPB_API_INLINE bool upb_MiniTableField_IsMap(const upb_MiniTableField* f);
1725
+ #endif /* UPB_MINI_TABLE_INTERNAL_SUB_H_ */
1875
1726
 
1876
- UPB_API_INLINE bool upb_MiniTableField_IsPacked(const upb_MiniTableField* f);
1727
+ // Must be last.
1877
1728
 
1878
- UPB_API_INLINE bool upb_MiniTableField_IsScalar(const upb_MiniTableField* f);
1729
+ struct upb_MiniTableExtension {
1730
+ // Do not move this field. We need to be able to alias pointers.
1731
+ struct upb_MiniTableField UPB_PRIVATE(field);
1879
1732
 
1880
- UPB_API_INLINE bool upb_MiniTableField_IsSubMessage(
1881
- const upb_MiniTableField* f);
1733
+ const struct upb_MiniTable* UPB_PRIVATE(extendee);
1734
+ union upb_MiniTableSub UPB_PRIVATE(sub); // NULL unless submsg or proto2 enum
1735
+ };
1882
1736
 
1883
- UPB_API_INLINE uint32_t upb_MiniTableField_Number(const upb_MiniTableField* f);
1737
+ #ifdef __cplusplus
1738
+ extern "C" {
1739
+ #endif
1884
1740
 
1885
- UPB_API_INLINE upb_FieldType
1886
- upb_MiniTableField_Type(const upb_MiniTableField* f);
1741
+ UPB_API_INLINE upb_CType
1742
+ upb_MiniTableExtension_CType(const struct upb_MiniTableExtension* e) {
1743
+ return upb_MiniTableField_CType(&e->UPB_PRIVATE(field));
1744
+ }
1745
+
1746
+ UPB_API_INLINE uint32_t
1747
+ upb_MiniTableExtension_Number(const struct upb_MiniTableExtension* e) {
1748
+ return e->UPB_PRIVATE(field).UPB_ONLYBITS(number);
1749
+ }
1750
+
1751
+ UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableExtension_GetSubMessage(
1752
+ const struct upb_MiniTableExtension* e) {
1753
+ if (upb_MiniTableExtension_CType(e) != kUpb_CType_Message) {
1754
+ return NULL;
1755
+ }
1756
+ return upb_MiniTableSub_Message(e->UPB_PRIVATE(sub));
1757
+ }
1758
+
1759
+ UPB_API_INLINE void upb_MiniTableExtension_SetSubMessage(
1760
+ struct upb_MiniTableExtension* e, const struct upb_MiniTable* m) {
1761
+ e->UPB_PRIVATE(sub).UPB_PRIVATE(submsg) = m;
1762
+ }
1763
+
1764
+ UPB_INLINE upb_FieldRep UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(
1765
+ const struct upb_MiniTableExtension* e) {
1766
+ return UPB_PRIVATE(_upb_MiniTableField_GetRep)(&e->UPB_PRIVATE(field));
1767
+ }
1887
1768
 
1888
1769
  #ifdef __cplusplus
1889
1770
  } /* extern "C" */
1890
1771
  #endif
1891
1772
 
1892
1773
 
1893
- #endif /* UPB_MINI_TABLE_FIELD_H_ */
1774
+ #endif /* UPB_MINI_TABLE_INTERNAL_EXTENSION_H_ */
1894
1775
 
1895
1776
  #ifndef UPB_MINI_TABLE_MESSAGE_H_
1896
1777
  #define UPB_MINI_TABLE_MESSAGE_H_
@@ -1970,62 +1851,60 @@ UPB_API_INLINE bool upb_MiniTableEnum_CheckValue(const upb_MiniTableEnum* e,
1970
1851
 
1971
1852
  #endif /* UPB_MINI_TABLE_ENUM_H_ */
1972
1853
 
1973
- #ifndef UPB_MINI_TABLE_INTERNAL_MESSAGE_H_
1974
- #define UPB_MINI_TABLE_INTERNAL_MESSAGE_H_
1854
+ #ifndef UPB_MINI_TABLE_FIELD_H_
1855
+ #define UPB_MINI_TABLE_FIELD_H_
1975
1856
 
1976
- #include <stddef.h>
1977
1857
  #include <stdint.h>
1978
1858
 
1979
1859
 
1980
- #ifndef UPB_MINI_TABLE_INTERNAL_SUB_H_
1981
- #define UPB_MINI_TABLE_INTERNAL_SUB_H_
1982
-
1983
1860
  // Must be last.
1984
1861
 
1985
- typedef union {
1986
- const struct upb_MiniTable* const* UPB_PRIVATE(submsg);
1987
- const struct upb_MiniTableEnum* UPB_PRIVATE(subenum);
1988
- } upb_MiniTableSubInternal;
1989
-
1990
- union upb_MiniTableSub {
1991
- const struct upb_MiniTable* UPB_PRIVATE(submsg);
1992
- const struct upb_MiniTableEnum* UPB_PRIVATE(subenum);
1993
- };
1862
+ typedef struct upb_MiniTableField upb_MiniTableField;
1994
1863
 
1995
1864
  #ifdef __cplusplus
1996
1865
  extern "C" {
1997
1866
  #endif
1998
1867
 
1999
- UPB_API_INLINE union upb_MiniTableSub upb_MiniTableSub_FromEnum(
2000
- const struct upb_MiniTableEnum* subenum) {
2001
- union upb_MiniTableSub out;
2002
- out.UPB_PRIVATE(subenum) = subenum;
2003
- return out;
2004
- }
1868
+ UPB_API_INLINE upb_CType upb_MiniTableField_CType(const upb_MiniTableField* f);
2005
1869
 
2006
- UPB_API_INLINE union upb_MiniTableSub upb_MiniTableSub_FromMessage(
2007
- const struct upb_MiniTable* submsg) {
2008
- union upb_MiniTableSub out;
2009
- out.UPB_PRIVATE(submsg) = submsg;
2010
- return out;
2011
- }
1870
+ UPB_API_INLINE bool upb_MiniTableField_HasPresence(const upb_MiniTableField* f);
2012
1871
 
2013
- UPB_API_INLINE const struct upb_MiniTableEnum* upb_MiniTableSub_Enum(
2014
- const union upb_MiniTableSub sub) {
2015
- return sub.UPB_PRIVATE(subenum);
2016
- }
1872
+ UPB_API_INLINE bool upb_MiniTableField_IsArray(const upb_MiniTableField* f);
2017
1873
 
2018
- UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableSub_Message(
2019
- const union upb_MiniTableSub sub) {
2020
- return sub.UPB_PRIVATE(submsg);
2021
- }
1874
+ UPB_API_INLINE bool upb_MiniTableField_IsClosedEnum(
1875
+ const upb_MiniTableField* f);
1876
+
1877
+ UPB_API_INLINE bool upb_MiniTableField_IsExtension(const upb_MiniTableField* f);
1878
+
1879
+ UPB_API_INLINE bool upb_MiniTableField_IsInOneof(const upb_MiniTableField* f);
1880
+
1881
+ UPB_API_INLINE bool upb_MiniTableField_IsMap(const upb_MiniTableField* f);
1882
+
1883
+ UPB_API_INLINE bool upb_MiniTableField_IsPacked(const upb_MiniTableField* f);
1884
+
1885
+ UPB_API_INLINE bool upb_MiniTableField_IsScalar(const upb_MiniTableField* f);
1886
+
1887
+ UPB_API_INLINE bool upb_MiniTableField_IsSubMessage(
1888
+ const upb_MiniTableField* f);
1889
+
1890
+ UPB_API_INLINE uint32_t upb_MiniTableField_Number(const upb_MiniTableField* f);
1891
+
1892
+ UPB_API_INLINE upb_FieldType
1893
+ upb_MiniTableField_Type(const upb_MiniTableField* f);
2022
1894
 
2023
1895
  #ifdef __cplusplus
2024
1896
  } /* extern "C" */
2025
1897
  #endif
2026
1898
 
2027
1899
 
2028
- #endif /* UPB_MINI_TABLE_INTERNAL_SUB_H_ */
1900
+ #endif /* UPB_MINI_TABLE_FIELD_H_ */
1901
+
1902
+ #ifndef UPB_MINI_TABLE_INTERNAL_MESSAGE_H_
1903
+ #define UPB_MINI_TABLE_INTERNAL_MESSAGE_H_
1904
+
1905
+ #include <stddef.h>
1906
+ #include <stdint.h>
1907
+
2029
1908
 
2030
1909
  // Must be last.
2031
1910
 
@@ -2294,90 +2173,73 @@ bool upb_MiniTable_NextOneofField(const upb_MiniTable* m,
2294
2173
 
2295
2174
  // Must be last.
2296
2175
 
2297
- typedef struct upb_Array upb_Array;
2176
+ typedef struct upb_MiniTableExtension upb_MiniTableExtension;
2298
2177
 
2299
2178
  #ifdef __cplusplus
2300
2179
  extern "C" {
2301
2180
  #endif
2302
2181
 
2303
- // Creates a new array on the given arena that holds elements of this type.
2304
- UPB_API upb_Array* upb_Array_New(upb_Arena* a, upb_CType type);
2305
-
2306
- // Returns the number of elements in the array.
2307
- UPB_API_INLINE size_t upb_Array_Size(const upb_Array* arr);
2308
-
2309
- // Returns the given element, which must be within the array's current size.
2310
- UPB_API upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i);
2182
+ UPB_API_INLINE upb_CType
2183
+ upb_MiniTableExtension_CType(const upb_MiniTableExtension* e);
2311
2184
 
2312
- // Returns a mutating pointer to the given element, which must be within the
2313
- // array's current size.
2314
- UPB_API upb_MutableMessageValue upb_Array_GetMutable(upb_Array* arr, size_t i);
2185
+ UPB_API_INLINE uint32_t
2186
+ upb_MiniTableExtension_Number(const upb_MiniTableExtension* e);
2315
2187
 
2316
- // Sets the given element, which must be within the array's current size.
2317
- UPB_API void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val);
2188
+ UPB_API_INLINE const upb_MiniTable* upb_MiniTableExtension_GetSubMessage(
2189
+ const upb_MiniTableExtension* e);
2318
2190
 
2319
- // Appends an element to the array. Returns false on allocation failure.
2320
- UPB_API bool upb_Array_Append(upb_Array* array, upb_MessageValue val,
2321
- upb_Arena* arena);
2191
+ UPB_API_INLINE void upb_MiniTableExtension_SetSubMessage(
2192
+ upb_MiniTableExtension* e, const upb_MiniTable* m);
2322
2193
 
2323
- // Moves elements within the array using memmove().
2324
- // Like memmove(), the source and destination elements may be overlapping.
2325
- UPB_API void upb_Array_Move(upb_Array* array, size_t dst_idx, size_t src_idx,
2326
- size_t count);
2194
+ #ifdef __cplusplus
2195
+ } /* extern "C" */
2196
+ #endif
2327
2197
 
2328
- // Inserts one or more empty elements into the array.
2329
- // Existing elements are shifted right.
2330
- // The new elements have undefined state and must be set with `upb_Array_Set()`.
2331
- // REQUIRES: `i <= upb_Array_Size(arr)`
2332
- UPB_API bool upb_Array_Insert(upb_Array* array, size_t i, size_t count,
2333
- upb_Arena* arena);
2334
2198
 
2335
- // Deletes one or more elements from the array.
2336
- // Existing elements are shifted left.
2337
- // REQUIRES: `i + count <= upb_Array_Size(arr)`
2338
- UPB_API void upb_Array_Delete(upb_Array* array, size_t i, size_t count);
2199
+ #endif /* UPB_MINI_TABLE_EXTENSION_H_ */
2339
2200
 
2340
- // Reserves |size| elements of storage for the array.
2341
- UPB_API_INLINE bool upb_Array_Reserve(struct upb_Array* array, size_t size,
2342
- upb_Arena* arena);
2201
+ // Must be last.
2343
2202
 
2344
- // Changes the size of a vector. New elements are initialized to NULL/0.
2345
- // Returns false on allocation failure.
2346
- UPB_API bool upb_Array_Resize(upb_Array* array, size_t size, upb_Arena* arena);
2203
+ // The internal representation of an extension is self-describing: it contains
2204
+ // enough information that we can serialize it to binary format without needing
2205
+ // to look it up in a upb_ExtensionRegistry.
2206
+ //
2207
+ // This representation allocates 16 bytes to data on 64-bit platforms.
2208
+ // This is rather wasteful for scalars (in the extreme case of bool,
2209
+ // it wastes 15 bytes). We accept this because we expect messages to be
2210
+ // the most common extension type.
2211
+ typedef struct {
2212
+ const upb_MiniTableExtension* ext;
2213
+ upb_MessageValue data;
2214
+ } upb_Extension;
2347
2215
 
2348
- // Returns pointer to array data.
2349
- UPB_API_INLINE const void* upb_Array_DataPtr(const upb_Array* arr);
2216
+ #ifdef __cplusplus
2217
+ extern "C" {
2218
+ #endif
2350
2219
 
2351
- // Returns mutable pointer to array data.
2352
- UPB_API_INLINE void* upb_Array_MutableDataPtr(upb_Array* arr);
2220
+ // Adds the given extension data to the given message.
2221
+ // |ext| is copied into the message instance.
2222
+ // This logically replaces any previously-added extension with this number.
2223
+ upb_Extension* UPB_PRIVATE(_upb_Message_GetOrCreateExtension)(
2224
+ struct upb_Message* msg, const upb_MiniTableExtension* ext,
2225
+ upb_Arena* arena);
2353
2226
 
2354
- // Mark an array and all of its descendents as frozen/immutable.
2355
- // If the array elements are messages then |m| must point to the minitable for
2356
- // those messages. Otherwise |m| must be NULL.
2357
- UPB_API void upb_Array_Freeze(upb_Array* arr, const upb_MiniTable* m);
2227
+ // Returns an array of extensions for this message.
2228
+ // Note: the array is ordered in reverse relative to the order of creation.
2229
+ const upb_Extension* UPB_PRIVATE(_upb_Message_Getexts)(
2230
+ const struct upb_Message* msg, size_t* count);
2358
2231
 
2359
- // Returns whether an array has been frozen.
2360
- UPB_API_INLINE bool upb_Array_IsFrozen(const upb_Array* arr);
2232
+ // Returns an extension for a message with a given mini table,
2233
+ // or NULL if no extension exists with this mini table.
2234
+ const upb_Extension* UPB_PRIVATE(_upb_Message_Getext)(
2235
+ const struct upb_Message* msg, const upb_MiniTableExtension* ext);
2361
2236
 
2362
2237
  #ifdef __cplusplus
2363
2238
  } /* extern "C" */
2364
2239
  #endif
2365
2240
 
2366
2241
 
2367
- #endif /* UPB_MESSAGE_ARRAY_H_ */
2368
-
2369
- #ifndef UPB_MESSAGE_INTERNAL_ACCESSORS_H_
2370
- #define UPB_MESSAGE_INTERNAL_ACCESSORS_H_
2371
-
2372
- #include <stddef.h>
2373
- #include <stdint.h>
2374
- #include <string.h>
2375
-
2376
-
2377
- #ifndef UPB_BASE_INTERNAL_ENDIAN_H_
2378
- #define UPB_BASE_INTERNAL_ENDIAN_H_
2379
-
2380
- #include <stdint.h>
2242
+ #endif /* UPB_MESSAGE_INTERNAL_EXTENSION_H_ */
2381
2243
 
2382
2244
  // Must be last.
2383
2245
 
@@ -2385,170 +2247,501 @@ UPB_API_INLINE bool upb_Array_IsFrozen(const upb_Array* arr);
2385
2247
  extern "C" {
2386
2248
  #endif
2387
2249
 
2388
- UPB_INLINE bool upb_IsLittleEndian(void) {
2389
- const int x = 1;
2390
- return *(char*)&x == 1;
2391
- }
2392
-
2393
- UPB_INLINE uint32_t upb_BigEndian32(uint32_t val) {
2394
- if (upb_IsLittleEndian()) return val;
2395
-
2396
- return ((val & 0xff) << 24) | ((val & 0xff00) << 8) |
2397
- ((val & 0xff0000) >> 8) | ((val & 0xff000000) >> 24);
2398
- }
2250
+ extern const float kUpb_FltInfinity;
2251
+ extern const double kUpb_Infinity;
2252
+ extern const double kUpb_NaN;
2399
2253
 
2400
- UPB_INLINE uint64_t upb_BigEndian64(uint64_t val) {
2401
- if (upb_IsLittleEndian()) return val;
2254
+ // Internal members of a upb_Message that track unknown fields and/or
2255
+ // extensions. We can change this without breaking binary compatibility.
2402
2256
 
2403
- const uint64_t hi = ((uint64_t)upb_BigEndian32((uint32_t)val)) << 32;
2404
- const uint64_t lo = upb_BigEndian32((uint32_t)(val >> 32));
2405
- return hi | lo;
2406
- }
2257
+ typedef struct upb_Message_Internal {
2258
+ // Total size of this structure, including the data that follows.
2259
+ // Must be aligned to 8, which is alignof(upb_Extension)
2260
+ uint32_t size;
2407
2261
 
2408
- #ifdef __cplusplus
2409
- } /* extern "C" */
2262
+ /* Offsets relative to the beginning of this structure.
2263
+ *
2264
+ * Unknown data grows forward from the beginning to unknown_end.
2265
+ * Extension data grows backward from size to ext_begin.
2266
+ * When the two meet, we're out of data and have to realloc.
2267
+ *
2268
+ * If we imagine that the final member of this struct is:
2269
+ * char data[size - overhead]; // overhead = sizeof(upb_Message_Internal)
2270
+ *
2271
+ * Then we have:
2272
+ * unknown data: data[0 .. (unknown_end - overhead)]
2273
+ * extensions data: data[(ext_begin - overhead) .. (size - overhead)] */
2274
+ uint32_t unknown_end;
2275
+ uint32_t ext_begin;
2276
+ // Data follows, as if there were an array:
2277
+ // char data[size - sizeof(upb_Message_Internal)];
2278
+ } upb_Message_Internal;
2279
+
2280
+ #ifdef UPB_TRACING_ENABLED
2281
+ UPB_API void upb_Message_LogNewMessage(const upb_MiniTable* m,
2282
+ const upb_Arena* arena);
2283
+ UPB_API void upb_Message_SetNewMessageTraceHandler(
2284
+ void (*handler)(const upb_MiniTable*, const upb_Arena*));
2285
+ #endif // UPB_TRACING_ENABLED
2286
+
2287
+ // Inline version upb_Message_New(), for internal use.
2288
+ UPB_INLINE struct upb_Message* _upb_Message_New(const upb_MiniTable* m,
2289
+ upb_Arena* a) {
2290
+ #ifdef UPB_TRACING_ENABLED
2291
+ upb_Message_LogNewMessage(m, a);
2292
+ #endif // UPB_TRACING_ENABLED
2293
+
2294
+ const int size = m->UPB_PRIVATE(size);
2295
+ struct upb_Message* msg = (struct upb_Message*)upb_Arena_Malloc(a, size);
2296
+ if (UPB_UNLIKELY(!msg)) return NULL;
2297
+ memset(msg, 0, size);
2298
+ return msg;
2299
+ }
2300
+
2301
+ // Discards the unknown fields for this message only.
2302
+ void _upb_Message_DiscardUnknown_shallow(struct upb_Message* msg);
2303
+
2304
+ // Adds unknown data (serialized protobuf data) to the given message.
2305
+ // The data is copied into the message instance.
2306
+ bool UPB_PRIVATE(_upb_Message_AddUnknown)(struct upb_Message* msg,
2307
+ const char* data, size_t len,
2308
+ upb_Arena* arena);
2309
+
2310
+ bool UPB_PRIVATE(_upb_Message_Realloc)(struct upb_Message* msg, size_t need,
2311
+ upb_Arena* arena);
2312
+
2313
+ #ifdef __cplusplus
2314
+ } /* extern "C" */
2410
2315
  #endif
2411
2316
 
2412
2317
 
2413
- #endif /* UPB_BASE_INTERNAL_ENDIAN_H_ */
2318
+ #endif /* UPB_MESSAGE_INTERNAL_MESSAGE_H_ */
2414
2319
 
2415
- #ifndef UPB_MESSAGE_INTERNAL_EXTENSION_H_
2416
- #define UPB_MESSAGE_INTERNAL_EXTENSION_H_
2320
+ #ifndef UPB_MESSAGE_INTERNAL_TYPES_H_
2321
+ #define UPB_MESSAGE_INTERNAL_TYPES_H_
2417
2322
 
2418
- #include <stddef.h>
2323
+ #include <stdint.h>
2324
+
2325
+ // Must be last.
2419
2326
 
2327
+ #define UPB_OPAQUE(x) x##_opaque
2420
2328
 
2421
- #ifndef UPB_MINI_TABLE_EXTENSION_H_
2422
- #define UPB_MINI_TABLE_EXTENSION_H_
2329
+ struct upb_Message {
2330
+ union {
2331
+ uintptr_t UPB_OPAQUE(internal); // tagged pointer, low bit == frozen
2332
+ double d; // Forces same size for 32-bit/64-bit builds
2333
+ };
2334
+ };
2335
+
2336
+ #ifdef __cplusplus
2337
+ extern "C" {
2338
+ #endif
2339
+
2340
+ UPB_INLINE void UPB_PRIVATE(_upb_Message_ShallowFreeze)(
2341
+ struct upb_Message* msg) {
2342
+ msg->UPB_OPAQUE(internal) |= 1ULL;
2343
+ }
2344
+
2345
+ UPB_API_INLINE bool upb_Message_IsFrozen(const struct upb_Message* msg) {
2346
+ return (msg->UPB_OPAQUE(internal) & 1ULL) != 0;
2347
+ }
2348
+
2349
+ UPB_INLINE struct upb_Message_Internal* UPB_PRIVATE(_upb_Message_GetInternal)(
2350
+ const struct upb_Message* msg) {
2351
+ const uintptr_t tmp = msg->UPB_OPAQUE(internal) & ~1ULL;
2352
+ return (struct upb_Message_Internal*)tmp;
2353
+ }
2354
+
2355
+ UPB_INLINE void UPB_PRIVATE(_upb_Message_SetInternal)(
2356
+ struct upb_Message* msg, struct upb_Message_Internal* internal) {
2357
+ UPB_ASSERT(!upb_Message_IsFrozen(msg));
2358
+ msg->UPB_OPAQUE(internal) = (uintptr_t)internal;
2359
+ }
2360
+
2361
+ #ifdef __cplusplus
2362
+ } /* extern "C" */
2363
+ #endif
2364
+
2365
+ #undef UPB_OPAQUE
2366
+
2367
+
2368
+ #endif /* UPB_MESSAGE_INTERNAL_TYPES_H_ */
2369
+
2370
+ // Must be last.
2371
+
2372
+ typedef struct upb_Message upb_Message;
2373
+
2374
+ #ifdef __cplusplus
2375
+ extern "C" {
2376
+ #endif
2377
+
2378
+ // Creates a new message with the given mini_table on the given arena.
2379
+ UPB_API upb_Message* upb_Message_New(const upb_MiniTable* m, upb_Arena* arena);
2380
+
2381
+ // Returns a reference to the message's unknown data.
2382
+ const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len);
2383
+
2384
+ // Removes partial unknown data from message.
2385
+ void upb_Message_DeleteUnknown(upb_Message* msg, const char* data, size_t len);
2386
+
2387
+ // Returns the number of extensions present in this message.
2388
+ size_t upb_Message_ExtensionCount(const upb_Message* msg);
2389
+
2390
+ // Mark a message and all of its descendents as frozen/immutable.
2391
+ UPB_API void upb_Message_Freeze(upb_Message* msg, const upb_MiniTable* m);
2392
+
2393
+ // Returns whether a message has been frozen.
2394
+ UPB_API_INLINE bool upb_Message_IsFrozen(const upb_Message* msg);
2395
+
2396
+ #ifdef UPB_TRACING_ENABLED
2397
+ UPB_API void upb_Message_LogNewMessage(const upb_MiniTable* m,
2398
+ const upb_Arena* arena);
2399
+
2400
+ UPB_API void upb_Message_SetNewMessageTraceHandler(
2401
+ void (*handler)(const upb_MiniTable* m, const upb_Arena* arena));
2402
+ #endif // UPB_TRACING_ENABLED
2403
+
2404
+ #ifdef __cplusplus
2405
+ } /* extern "C" */
2406
+ #endif
2407
+
2408
+
2409
+ #endif /* UPB_MESSAGE_MESSAGE_H_ */
2410
+
2411
+ #ifndef UPB_REFLECTION_DEF_H_
2412
+ #define UPB_REFLECTION_DEF_H_
2413
+
2414
+ // IWYU pragma: begin_exports
2415
+
2416
+ // IWYU pragma: private, include "upb/reflection/def.h"
2417
+
2418
+ #ifndef UPB_REFLECTION_DEF_POOL_H_
2419
+ #define UPB_REFLECTION_DEF_POOL_H_
2420
+
2421
+
2422
+ // IWYU pragma: private, include "upb/reflection/def.h"
2423
+
2424
+ // Declarations common to all public def types.
2425
+
2426
+ #ifndef UPB_REFLECTION_COMMON_H_
2427
+ #define UPB_REFLECTION_COMMON_H_
2428
+
2429
+ #ifndef THIRD_PARTY_UPB_UPB_REFLECTION_DESCRIPTOR_BOOTSTRAP_H_
2430
+ #define THIRD_PARTY_UPB_UPB_REFLECTION_DESCRIPTOR_BOOTSTRAP_H_
2431
+
2432
+ // IWYU pragma: begin_exports
2433
+
2434
+ #if defined(UPB_BOOTSTRAP_STAGE) && UPB_BOOTSTRAP_STAGE == 0
2435
+ // This header is checked in.
2436
+ #elif UPB_BOOTSTRAP_STAGE == 1
2437
+ // This header is generated at build time by the bootstrapping process.
2438
+ #else
2439
+ // This is the normal header, generated by upb_c_proto_library().
2440
+ /* This file was generated by upb_generator from the input file:
2441
+ *
2442
+ * google/protobuf/descriptor.proto
2443
+ *
2444
+ * Do not edit -- your changes will be discarded when the file is
2445
+ * regenerated.
2446
+ * NO CHECKED-IN PROTOBUF GENCODE */
2447
+
2448
+ #ifndef GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H__UPB_H_
2449
+ #define GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H__UPB_H_
2450
+
2451
+
2452
+ #ifndef UPB_GENERATED_CODE_SUPPORT_H_
2453
+ #define UPB_GENERATED_CODE_SUPPORT_H_
2454
+
2455
+ // IWYU pragma: begin_exports
2456
+
2457
+ #ifndef UPB_BASE_UPCAST_H_
2458
+ #define UPB_BASE_UPCAST_H_
2459
+
2460
+ // Must be last.
2461
+
2462
+ // This macro provides a way to upcast message pointers in a way that is
2463
+ // somewhat more bulletproof than blindly casting a pointer. Example:
2464
+ //
2465
+ // typedef struct {
2466
+ // upb_Message UPB_PRIVATE(base);
2467
+ // } pkg_FooMessage;
2468
+ //
2469
+ // void f(pkg_FooMessage* msg) {
2470
+ // upb_Decode(UPB_UPCAST(msg), ...);
2471
+ // }
2472
+
2473
+ #define UPB_UPCAST(x) (&(x)->base##_dont_copy_me__upb_internal_use_only)
2474
+
2475
+
2476
+ #endif /* UPB_BASE_UPCAST_H_ */
2477
+
2478
+ #ifndef UPB_MESSAGE_ACCESSORS_H_
2479
+ #define UPB_MESSAGE_ACCESSORS_H_
2423
2480
 
2424
2481
  #include <stdint.h>
2425
2482
 
2426
2483
 
2427
- #ifndef UPB_MINI_TABLE_INTERNAL_EXTENSION_H_
2428
- #define UPB_MINI_TABLE_INTERNAL_EXTENSION_H_
2484
+ #ifndef UPB_MESSAGE_ARRAY_H_
2485
+ #define UPB_MESSAGE_ARRAY_H_
2429
2486
 
2430
2487
  #include <stddef.h>
2488
+
2489
+
2490
+ #ifndef UPB_MESSAGE_INTERNAL_ARRAY_H_
2491
+ #define UPB_MESSAGE_INTERNAL_ARRAY_H_
2492
+
2431
2493
  #include <stdint.h>
2494
+ #include <string.h>
2432
2495
 
2433
2496
 
2434
2497
  // Must be last.
2435
2498
 
2436
- struct upb_MiniTableExtension {
2437
- // Do not move this field. We need to be able to alias pointers.
2438
- struct upb_MiniTableField UPB_PRIVATE(field);
2439
-
2440
- const struct upb_MiniTable* UPB_PRIVATE(extendee);
2441
- union upb_MiniTableSub UPB_PRIVATE(sub); // NULL unless submsg or proto2 enum
2442
- };
2499
+ #define _UPB_ARRAY_MASK_IMM 0x4 // Frozen/immutable bit.
2500
+ #define _UPB_ARRAY_MASK_LG2 0x3 // Encoded elem size.
2501
+ #define _UPB_ARRAY_MASK_ALL (_UPB_ARRAY_MASK_IMM | _UPB_ARRAY_MASK_LG2)
2443
2502
 
2444
2503
  #ifdef __cplusplus
2445
2504
  extern "C" {
2446
2505
  #endif
2447
2506
 
2448
- UPB_API_INLINE upb_CType
2449
- upb_MiniTableExtension_CType(const struct upb_MiniTableExtension* e) {
2450
- return upb_MiniTableField_CType(&e->UPB_PRIVATE(field));
2507
+ // LINT.IfChange(upb_Array)
2508
+
2509
+ // Our internal representation for repeated fields.
2510
+ struct upb_Array {
2511
+ // This is a tagged pointer. Bits #0 and #1 encode the elem size as follows:
2512
+ // 0 maps to elem size 1
2513
+ // 1 maps to elem size 4
2514
+ // 2 maps to elem size 8
2515
+ // 3 maps to elem size 16
2516
+ //
2517
+ // Bit #2 contains the frozen/immutable flag.
2518
+ uintptr_t UPB_ONLYBITS(data);
2519
+
2520
+ size_t UPB_ONLYBITS(size); // The number of elements in the array.
2521
+ size_t UPB_PRIVATE(capacity); // Allocated storage. Measured in elements.
2522
+ };
2523
+
2524
+ UPB_INLINE void UPB_PRIVATE(_upb_Array_ShallowFreeze)(struct upb_Array* arr) {
2525
+ arr->UPB_ONLYBITS(data) |= _UPB_ARRAY_MASK_IMM;
2451
2526
  }
2452
2527
 
2453
- UPB_API_INLINE uint32_t
2454
- upb_MiniTableExtension_Number(const struct upb_MiniTableExtension* e) {
2455
- return e->UPB_PRIVATE(field).UPB_ONLYBITS(number);
2528
+ UPB_API_INLINE bool upb_Array_IsFrozen(const struct upb_Array* arr) {
2529
+ return (arr->UPB_ONLYBITS(data) & _UPB_ARRAY_MASK_IMM) != 0;
2456
2530
  }
2457
2531
 
2458
- UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableExtension_GetSubMessage(
2459
- const struct upb_MiniTableExtension* e) {
2460
- if (upb_MiniTableExtension_CType(e) != kUpb_CType_Message) {
2461
- return NULL;
2462
- }
2463
- return upb_MiniTableSub_Message(e->UPB_PRIVATE(sub));
2532
+ UPB_INLINE void UPB_PRIVATE(_upb_Array_SetTaggedPtr)(struct upb_Array* array,
2533
+ void* data, size_t lg2) {
2534
+ UPB_ASSERT(lg2 != 1);
2535
+ UPB_ASSERT(lg2 <= 4);
2536
+ const size_t bits = lg2 - (lg2 != 0);
2537
+ array->UPB_ONLYBITS(data) = (uintptr_t)data | bits;
2464
2538
  }
2465
2539
 
2466
- UPB_API_INLINE void upb_MiniTableExtension_SetSubMessage(
2467
- struct upb_MiniTableExtension* e, const struct upb_MiniTable* m) {
2468
- e->UPB_PRIVATE(sub).UPB_PRIVATE(submsg) = m;
2540
+ UPB_INLINE size_t
2541
+ UPB_PRIVATE(_upb_Array_ElemSizeLg2)(const struct upb_Array* array) {
2542
+ const size_t bits = array->UPB_ONLYBITS(data) & _UPB_ARRAY_MASK_LG2;
2543
+ const size_t lg2 = bits + (bits != 0);
2544
+ return lg2;
2469
2545
  }
2470
2546
 
2471
- UPB_INLINE upb_FieldRep UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(
2472
- const struct upb_MiniTableExtension* e) {
2473
- return UPB_PRIVATE(_upb_MiniTableField_GetRep)(&e->UPB_PRIVATE(field));
2547
+ UPB_API_INLINE const void* upb_Array_DataPtr(const struct upb_Array* array) {
2548
+ UPB_PRIVATE(_upb_Array_ElemSizeLg2)(array); // Check assertions.
2549
+ return (void*)(array->UPB_ONLYBITS(data) & ~(uintptr_t)_UPB_ARRAY_MASK_ALL);
2550
+ }
2551
+
2552
+ UPB_API_INLINE void* upb_Array_MutableDataPtr(struct upb_Array* array) {
2553
+ return (void*)upb_Array_DataPtr(array);
2554
+ }
2555
+
2556
+ UPB_INLINE struct upb_Array* UPB_PRIVATE(_upb_Array_New)(upb_Arena* arena,
2557
+ size_t init_capacity,
2558
+ int elem_size_lg2) {
2559
+ UPB_ASSERT(elem_size_lg2 != 1);
2560
+ UPB_ASSERT(elem_size_lg2 <= 4);
2561
+ const size_t array_size =
2562
+ UPB_ALIGN_UP(sizeof(struct upb_Array), UPB_MALLOC_ALIGN);
2563
+ const size_t bytes = array_size + (init_capacity << elem_size_lg2);
2564
+ struct upb_Array* array = (struct upb_Array*)upb_Arena_Malloc(arena, bytes);
2565
+ if (!array) return NULL;
2566
+ UPB_PRIVATE(_upb_Array_SetTaggedPtr)
2567
+ (array, UPB_PTR_AT(array, array_size, void), elem_size_lg2);
2568
+ array->UPB_ONLYBITS(size) = 0;
2569
+ array->UPB_PRIVATE(capacity) = init_capacity;
2570
+ return array;
2571
+ }
2572
+
2573
+ // Resizes the capacity of the array to be at least min_size.
2574
+ bool UPB_PRIVATE(_upb_Array_Realloc)(struct upb_Array* array, size_t min_size,
2575
+ upb_Arena* arena);
2576
+
2577
+ UPB_API_INLINE bool upb_Array_Reserve(struct upb_Array* array, size_t size,
2578
+ upb_Arena* arena) {
2579
+ UPB_ASSERT(!upb_Array_IsFrozen(array));
2580
+ if (array->UPB_PRIVATE(capacity) < size)
2581
+ return UPB_PRIVATE(_upb_Array_Realloc)(array, size, arena);
2582
+ return true;
2583
+ }
2584
+
2585
+ // Resize without initializing new elements.
2586
+ UPB_INLINE bool UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
2587
+ struct upb_Array* array, size_t size, upb_Arena* arena) {
2588
+ UPB_ASSERT(!upb_Array_IsFrozen(array));
2589
+ UPB_ASSERT(size <= array->UPB_ONLYBITS(size) ||
2590
+ arena); // Allow NULL arena when shrinking.
2591
+ if (!upb_Array_Reserve(array, size, arena)) return false;
2592
+ array->UPB_ONLYBITS(size) = size;
2593
+ return true;
2474
2594
  }
2475
2595
 
2596
+ // This function is intended for situations where elem_size is compile-time
2597
+ // constant or a known expression of the form (1 << lg2), so that the expression
2598
+ // i*elem_size does not result in an actual multiplication.
2599
+ UPB_INLINE void UPB_PRIVATE(_upb_Array_Set)(struct upb_Array* array, size_t i,
2600
+ const void* data,
2601
+ size_t elem_size) {
2602
+ UPB_ASSERT(!upb_Array_IsFrozen(array));
2603
+ UPB_ASSERT(i < array->UPB_ONLYBITS(size));
2604
+ UPB_ASSERT(elem_size == 1U << UPB_PRIVATE(_upb_Array_ElemSizeLg2)(array));
2605
+ char* arr_data = (char*)upb_Array_MutableDataPtr(array);
2606
+ memcpy(arr_data + (i * elem_size), data, elem_size);
2607
+ }
2608
+
2609
+ UPB_API_INLINE size_t upb_Array_Size(const struct upb_Array* arr) {
2610
+ return arr->UPB_ONLYBITS(size);
2611
+ }
2612
+
2613
+ // LINT.ThenChange(GoogleInternalName0)
2614
+
2476
2615
  #ifdef __cplusplus
2477
2616
  } /* extern "C" */
2478
2617
  #endif
2479
2618
 
2619
+ #undef _UPB_ARRAY_MASK_IMM
2620
+ #undef _UPB_ARRAY_MASK_LG2
2621
+ #undef _UPB_ARRAY_MASK_ALL
2480
2622
 
2481
- #endif /* UPB_MINI_TABLE_INTERNAL_EXTENSION_H_ */
2623
+
2624
+ #endif /* UPB_MESSAGE_INTERNAL_ARRAY_H_ */
2482
2625
 
2483
2626
  // Must be last.
2484
2627
 
2485
- typedef struct upb_MiniTableExtension upb_MiniTableExtension;
2628
+ typedef struct upb_Array upb_Array;
2486
2629
 
2487
2630
  #ifdef __cplusplus
2488
2631
  extern "C" {
2489
2632
  #endif
2490
2633
 
2491
- UPB_API_INLINE upb_CType
2492
- upb_MiniTableExtension_CType(const upb_MiniTableExtension* e);
2634
+ // Creates a new array on the given arena that holds elements of this type.
2635
+ UPB_API upb_Array* upb_Array_New(upb_Arena* a, upb_CType type);
2493
2636
 
2494
- UPB_API_INLINE uint32_t
2495
- upb_MiniTableExtension_Number(const upb_MiniTableExtension* e);
2637
+ // Returns the number of elements in the array.
2638
+ UPB_API_INLINE size_t upb_Array_Size(const upb_Array* arr);
2496
2639
 
2497
- UPB_API_INLINE const upb_MiniTable* upb_MiniTableExtension_GetSubMessage(
2498
- const upb_MiniTableExtension* e);
2640
+ // Returns the given element, which must be within the array's current size.
2641
+ UPB_API upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i);
2642
+
2643
+ // Returns a mutating pointer to the given element, which must be within the
2644
+ // array's current size.
2645
+ UPB_API upb_MutableMessageValue upb_Array_GetMutable(upb_Array* arr, size_t i);
2646
+
2647
+ // Sets the given element, which must be within the array's current size.
2648
+ UPB_API void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val);
2649
+
2650
+ // Appends an element to the array. Returns false on allocation failure.
2651
+ UPB_API bool upb_Array_Append(upb_Array* array, upb_MessageValue val,
2652
+ upb_Arena* arena);
2653
+
2654
+ // Moves elements within the array using memmove().
2655
+ // Like memmove(), the source and destination elements may be overlapping.
2656
+ UPB_API void upb_Array_Move(upb_Array* array, size_t dst_idx, size_t src_idx,
2657
+ size_t count);
2658
+
2659
+ // Inserts one or more empty elements into the array.
2660
+ // Existing elements are shifted right.
2661
+ // The new elements have undefined state and must be set with `upb_Array_Set()`.
2662
+ // REQUIRES: `i <= upb_Array_Size(arr)`
2663
+ UPB_API bool upb_Array_Insert(upb_Array* array, size_t i, size_t count,
2664
+ upb_Arena* arena);
2665
+
2666
+ // Deletes one or more elements from the array.
2667
+ // Existing elements are shifted left.
2668
+ // REQUIRES: `i + count <= upb_Array_Size(arr)`
2669
+ UPB_API void upb_Array_Delete(upb_Array* array, size_t i, size_t count);
2670
+
2671
+ // Reserves |size| elements of storage for the array.
2672
+ UPB_API_INLINE bool upb_Array_Reserve(struct upb_Array* array, size_t size,
2673
+ upb_Arena* arena);
2674
+
2675
+ // Changes the size of a vector. New elements are initialized to NULL/0.
2676
+ // Returns false on allocation failure.
2677
+ UPB_API bool upb_Array_Resize(upb_Array* array, size_t size, upb_Arena* arena);
2678
+
2679
+ // Returns pointer to array data.
2680
+ UPB_API_INLINE const void* upb_Array_DataPtr(const upb_Array* arr);
2681
+
2682
+ // Returns mutable pointer to array data.
2683
+ UPB_API_INLINE void* upb_Array_MutableDataPtr(upb_Array* arr);
2684
+
2685
+ // Mark an array and all of its descendents as frozen/immutable.
2686
+ // If the array elements are messages then |m| must point to the minitable for
2687
+ // those messages. Otherwise |m| must be NULL.
2688
+ UPB_API void upb_Array_Freeze(upb_Array* arr, const upb_MiniTable* m);
2689
+
2690
+ // Returns whether an array has been frozen.
2691
+ UPB_API_INLINE bool upb_Array_IsFrozen(const upb_Array* arr);
2692
+
2693
+ #ifdef __cplusplus
2694
+ } /* extern "C" */
2695
+ #endif
2696
+
2697
+
2698
+ #endif /* UPB_MESSAGE_ARRAY_H_ */
2699
+
2700
+ #ifndef UPB_MESSAGE_INTERNAL_ACCESSORS_H_
2701
+ #define UPB_MESSAGE_INTERNAL_ACCESSORS_H_
2499
2702
 
2500
- UPB_API_INLINE void upb_MiniTableExtension_SetSubMessage(
2501
- upb_MiniTableExtension* e, const upb_MiniTable* m);
2703
+ #include <stddef.h>
2704
+ #include <stdint.h>
2705
+ #include <string.h>
2502
2706
 
2503
- #ifdef __cplusplus
2504
- } /* extern "C" */
2505
- #endif
2506
2707
 
2708
+ #ifndef UPB_BASE_INTERNAL_ENDIAN_H_
2709
+ #define UPB_BASE_INTERNAL_ENDIAN_H_
2507
2710
 
2508
- #endif /* UPB_MINI_TABLE_EXTENSION_H_ */
2711
+ #include <stdint.h>
2509
2712
 
2510
2713
  // Must be last.
2511
2714
 
2512
- // The internal representation of an extension is self-describing: it contains
2513
- // enough information that we can serialize it to binary format without needing
2514
- // to look it up in a upb_ExtensionRegistry.
2515
- //
2516
- // This representation allocates 16 bytes to data on 64-bit platforms.
2517
- // This is rather wasteful for scalars (in the extreme case of bool,
2518
- // it wastes 15 bytes). We accept this because we expect messages to be
2519
- // the most common extension type.
2520
- typedef struct {
2521
- const upb_MiniTableExtension* ext;
2522
- upb_MessageValue data;
2523
- } upb_Extension;
2524
-
2525
2715
  #ifdef __cplusplus
2526
2716
  extern "C" {
2527
2717
  #endif
2528
2718
 
2529
- // Adds the given extension data to the given message.
2530
- // |ext| is copied into the message instance.
2531
- // This logically replaces any previously-added extension with this number.
2532
- upb_Extension* UPB_PRIVATE(_upb_Message_GetOrCreateExtension)(
2533
- struct upb_Message* msg, const upb_MiniTableExtension* ext,
2534
- upb_Arena* arena);
2719
+ UPB_INLINE bool upb_IsLittleEndian(void) {
2720
+ const int x = 1;
2721
+ return *(char*)&x == 1;
2722
+ }
2535
2723
 
2536
- // Returns an array of extensions for this message.
2537
- // Note: the array is ordered in reverse relative to the order of creation.
2538
- const upb_Extension* UPB_PRIVATE(_upb_Message_Getexts)(
2539
- const struct upb_Message* msg, size_t* count);
2724
+ UPB_INLINE uint32_t upb_BigEndian32(uint32_t val) {
2725
+ if (upb_IsLittleEndian()) return val;
2540
2726
 
2541
- // Returns an extension for a message with a given mini table,
2542
- // or NULL if no extension exists with this mini table.
2543
- const upb_Extension* UPB_PRIVATE(_upb_Message_Getext)(
2544
- const struct upb_Message* msg, const upb_MiniTableExtension* ext);
2727
+ return ((val & 0xff) << 24) | ((val & 0xff00) << 8) |
2728
+ ((val & 0xff0000) >> 8) | ((val & 0xff000000) >> 24);
2729
+ }
2730
+
2731
+ UPB_INLINE uint64_t upb_BigEndian64(uint64_t val) {
2732
+ if (upb_IsLittleEndian()) return val;
2733
+
2734
+ const uint64_t hi = ((uint64_t)upb_BigEndian32((uint32_t)val)) << 32;
2735
+ const uint64_t lo = upb_BigEndian32((uint32_t)(val >> 32));
2736
+ return hi | lo;
2737
+ }
2545
2738
 
2546
2739
  #ifdef __cplusplus
2547
2740
  } /* extern "C" */
2548
2741
  #endif
2549
2742
 
2550
2743
 
2551
- #endif /* UPB_MESSAGE_INTERNAL_EXTENSION_H_ */
2744
+ #endif /* UPB_BASE_INTERNAL_ENDIAN_H_ */
2552
2745
 
2553
2746
  #ifndef UPB_MESSAGE_INTERNAL_MAP_H_
2554
2747
  #define UPB_MESSAGE_INTERNAL_MAP_H_
@@ -3010,96 +3203,6 @@ struct upb_Map* _upb_Map_New(upb_Arena* a, size_t key_size, size_t value_size);
3010
3203
 
3011
3204
  #endif /* UPB_MESSAGE_INTERNAL_MAP_H_ */
3012
3205
 
3013
- /*
3014
- ** Our memory representation for parsing tables and messages themselves.
3015
- ** Functions in this file are used by generated code and possibly reflection.
3016
- **
3017
- ** The definitions in this file are internal to upb.
3018
- **/
3019
-
3020
- #ifndef UPB_MESSAGE_INTERNAL_MESSAGE_H_
3021
- #define UPB_MESSAGE_INTERNAL_MESSAGE_H_
3022
-
3023
- #include <stdlib.h>
3024
- #include <string.h>
3025
-
3026
-
3027
- // Must be last.
3028
-
3029
- #ifdef __cplusplus
3030
- extern "C" {
3031
- #endif
3032
-
3033
- extern const float kUpb_FltInfinity;
3034
- extern const double kUpb_Infinity;
3035
- extern const double kUpb_NaN;
3036
-
3037
- // Internal members of a upb_Message that track unknown fields and/or
3038
- // extensions. We can change this without breaking binary compatibility.
3039
-
3040
- typedef struct upb_Message_Internal {
3041
- // Total size of this structure, including the data that follows.
3042
- // Must be aligned to 8, which is alignof(upb_Extension)
3043
- uint32_t size;
3044
-
3045
- /* Offsets relative to the beginning of this structure.
3046
- *
3047
- * Unknown data grows forward from the beginning to unknown_end.
3048
- * Extension data grows backward from size to ext_begin.
3049
- * When the two meet, we're out of data and have to realloc.
3050
- *
3051
- * If we imagine that the final member of this struct is:
3052
- * char data[size - overhead]; // overhead = sizeof(upb_Message_Internal)
3053
- *
3054
- * Then we have:
3055
- * unknown data: data[0 .. (unknown_end - overhead)]
3056
- * extensions data: data[(ext_begin - overhead) .. (size - overhead)] */
3057
- uint32_t unknown_end;
3058
- uint32_t ext_begin;
3059
- // Data follows, as if there were an array:
3060
- // char data[size - sizeof(upb_Message_Internal)];
3061
- } upb_Message_Internal;
3062
-
3063
- #ifdef UPB_TRACING_ENABLED
3064
- UPB_API void upb_Message_LogNewMessage(const upb_MiniTable* m,
3065
- const upb_Arena* arena);
3066
- UPB_API void upb_Message_SetNewMessageTraceHandler(
3067
- void (*handler)(const upb_MiniTable*, const upb_Arena*));
3068
- #endif // UPB_TRACING_ENABLED
3069
-
3070
- // Inline version upb_Message_New(), for internal use.
3071
- UPB_INLINE struct upb_Message* _upb_Message_New(const upb_MiniTable* m,
3072
- upb_Arena* a) {
3073
- #ifdef UPB_TRACING_ENABLED
3074
- upb_Message_LogNewMessage(m, a);
3075
- #endif // UPB_TRACING_ENABLED
3076
-
3077
- const int size = m->UPB_PRIVATE(size);
3078
- struct upb_Message* msg = (struct upb_Message*)upb_Arena_Malloc(a, size);
3079
- if (UPB_UNLIKELY(!msg)) return NULL;
3080
- memset(msg, 0, size);
3081
- return msg;
3082
- }
3083
-
3084
- // Discards the unknown fields for this message only.
3085
- void _upb_Message_DiscardUnknown_shallow(struct upb_Message* msg);
3086
-
3087
- // Adds unknown data (serialized protobuf data) to the given message.
3088
- // The data is copied into the message instance.
3089
- bool UPB_PRIVATE(_upb_Message_AddUnknown)(struct upb_Message* msg,
3090
- const char* data, size_t len,
3091
- upb_Arena* arena);
3092
-
3093
- bool UPB_PRIVATE(_upb_Message_Realloc)(struct upb_Message* msg, size_t need,
3094
- upb_Arena* arena);
3095
-
3096
- #ifdef __cplusplus
3097
- } /* extern "C" */
3098
- #endif
3099
-
3100
-
3101
- #endif /* UPB_MESSAGE_INTERNAL_MESSAGE_H_ */
3102
-
3103
3206
  #ifndef UPB_MINI_TABLE_INTERNAL_TAGGED_PTR_H_
3104
3207
  #define UPB_MINI_TABLE_INTERNAL_TAGGED_PTR_H_
3105
3208
 
@@ -3147,56 +3250,6 @@ UPB_INLINE struct upb_Message* UPB_PRIVATE(
3147
3250
 
3148
3251
  #endif /* UPB_MINI_TABLE_INTERNAL_TAGGED_PTR_H_ */
3149
3252
 
3150
- #ifndef UPB_MESSAGE_INTERNAL_TYPES_H_
3151
- #define UPB_MESSAGE_INTERNAL_TYPES_H_
3152
-
3153
- #include <stdint.h>
3154
-
3155
- // Must be last.
3156
-
3157
- #define UPB_OPAQUE(x) x##_opaque
3158
-
3159
- struct upb_Message {
3160
- union {
3161
- uintptr_t UPB_OPAQUE(internal); // tagged pointer, low bit == frozen
3162
- double d; // Forces same size for 32-bit/64-bit builds
3163
- };
3164
- };
3165
-
3166
- #ifdef __cplusplus
3167
- extern "C" {
3168
- #endif
3169
-
3170
- UPB_INLINE void UPB_PRIVATE(_upb_Message_ShallowFreeze)(
3171
- struct upb_Message* msg) {
3172
- msg->UPB_OPAQUE(internal) |= 1ULL;
3173
- }
3174
-
3175
- UPB_API_INLINE bool upb_Message_IsFrozen(const struct upb_Message* msg) {
3176
- return (msg->UPB_OPAQUE(internal) & 1ULL) != 0;
3177
- }
3178
-
3179
- UPB_INLINE struct upb_Message_Internal* UPB_PRIVATE(_upb_Message_GetInternal)(
3180
- const struct upb_Message* msg) {
3181
- const uintptr_t tmp = msg->UPB_OPAQUE(internal) & ~1ULL;
3182
- return (struct upb_Message_Internal*)tmp;
3183
- }
3184
-
3185
- UPB_INLINE void UPB_PRIVATE(_upb_Message_SetInternal)(
3186
- struct upb_Message* msg, struct upb_Message_Internal* internal) {
3187
- UPB_ASSERT(!upb_Message_IsFrozen(msg));
3188
- msg->UPB_OPAQUE(internal) = (uintptr_t)internal;
3189
- }
3190
-
3191
- #ifdef __cplusplus
3192
- } /* extern "C" */
3193
- #endif
3194
-
3195
- #undef UPB_OPAQUE
3196
-
3197
-
3198
- #endif /* UPB_MESSAGE_INTERNAL_TYPES_H_ */
3199
-
3200
3253
  // Must be last.
3201
3254
 
3202
3255
  #if defined(__GNUC__) && !defined(__clang__)
@@ -4203,57 +4256,6 @@ UPB_API_INLINE bool upb_Map_IsFrozen(const upb_Map* map);
4203
4256
 
4204
4257
  #endif /* UPB_MESSAGE_MAP_H_ */
4205
4258
 
4206
- // Public APIs for message operations that do not depend on the schema.
4207
- //
4208
- // MiniTable-based accessors live in accessors.h.
4209
-
4210
- #ifndef UPB_MESSAGE_MESSAGE_H_
4211
- #define UPB_MESSAGE_MESSAGE_H_
4212
-
4213
- #include <stddef.h>
4214
-
4215
-
4216
- // Must be last.
4217
-
4218
- typedef struct upb_Message upb_Message;
4219
-
4220
- #ifdef __cplusplus
4221
- extern "C" {
4222
- #endif
4223
-
4224
- // Creates a new message with the given mini_table on the given arena.
4225
- UPB_API upb_Message* upb_Message_New(const upb_MiniTable* m, upb_Arena* arena);
4226
-
4227
- // Returns a reference to the message's unknown data.
4228
- const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len);
4229
-
4230
- // Removes partial unknown data from message.
4231
- void upb_Message_DeleteUnknown(upb_Message* msg, const char* data, size_t len);
4232
-
4233
- // Returns the number of extensions present in this message.
4234
- size_t upb_Message_ExtensionCount(const upb_Message* msg);
4235
-
4236
- // Mark a message and all of its descendents as frozen/immutable.
4237
- UPB_API void upb_Message_Freeze(upb_Message* msg, const upb_MiniTable* m);
4238
-
4239
- // Returns whether a message has been frozen.
4240
- UPB_API_INLINE bool upb_Message_IsFrozen(const upb_Message* msg);
4241
-
4242
- #ifdef UPB_TRACING_ENABLED
4243
- UPB_API void upb_Message_LogNewMessage(const upb_MiniTable* m,
4244
- const upb_Arena* arena);
4245
-
4246
- UPB_API void upb_Message_SetNewMessageTraceHandler(
4247
- void (*handler)(const upb_MiniTable* m, const upb_Arena* arena));
4248
- #endif // UPB_TRACING_ENABLED
4249
-
4250
- #ifdef __cplusplus
4251
- } /* extern "C" */
4252
- #endif
4253
-
4254
-
4255
- #endif /* UPB_MESSAGE_MESSAGE_H_ */
4256
-
4257
4259
  #ifndef UPB_MINI_TABLE_TAGGED_PTR_H_
4258
4260
  #define UPB_MINI_TABLE_TAGGED_PTR_H_
4259
4261
 
@@ -13019,9 +13021,27 @@ extern "C" {
13019
13021
 
13020
13022
  enum { upb_JsonDecode_IgnoreUnknown = 1 };
13021
13023
 
13022
- UPB_API bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg,
13023
- const upb_MessageDef* m, const upb_DefPool* symtab,
13024
- int options, upb_Arena* arena, upb_Status* status);
13024
+ enum {
13025
+ kUpb_JsonDecodeResult_Ok = 0,
13026
+ kUpb_JsonDecodeResult_OkWithEmptyStringNumerics = 1,
13027
+ kUpb_JsonDecodeResult_Error = 2,
13028
+ };
13029
+
13030
+ UPB_API int upb_JsonDecodeDetectingNonconformance(const char* buf, size_t size,
13031
+ upb_Message* msg,
13032
+ const upb_MessageDef* m,
13033
+ const upb_DefPool* symtab,
13034
+ int options, upb_Arena* arena,
13035
+ upb_Status* status);
13036
+
13037
+ UPB_API_INLINE bool upb_JsonDecode(const char* buf, size_t size,
13038
+ upb_Message* msg, const upb_MessageDef* m,
13039
+ const upb_DefPool* symtab, int options,
13040
+ upb_Arena* arena, upb_Status* status) {
13041
+ return upb_JsonDecodeDetectingNonconformance(buf, size, msg, m, symtab,
13042
+ options, arena, status) ==
13043
+ kUpb_JsonDecodeResult_Ok;
13044
+ }
13025
13045
 
13026
13046
  #ifdef __cplusplus
13027
13047
  } /* extern "C" */