google-protobuf 4.26.1-x64-mingw-ucrt → 4.27.0.rc.1-x64-mingw-ucrt
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.
Potentially problematic release.
This version of google-protobuf might be problematic. Click here for more details.
- checksums.yaml +4 -4
- data/ext/google/protobuf_c/defs.c +327 -1
- data/ext/google/protobuf_c/glue.c +16 -0
- data/ext/google/protobuf_c/message.c +4 -15
- data/ext/google/protobuf_c/message.h +0 -4
- data/ext/google/protobuf_c/ruby-upb.c +1200 -279
- data/ext/google/protobuf_c/ruby-upb.h +1164 -809
- data/ext/google/protobuf_c/shared_convert.c +5 -2
- data/ext/google/protobuf_c/shared_message.c +0 -30
- data/ext/google/protobuf_c/shared_message.h +0 -4
- data/lib/google/3.1/protobuf_c.so +0 -0
- data/lib/google/3.2/protobuf_c.so +0 -0
- data/lib/google/3.3/protobuf_c.so +0 -0
- data/lib/google/protobuf/descriptor_pb.rb +2 -1
- data/lib/google/protobuf/ffi/descriptor.rb +3 -1
- data/lib/google/protobuf/ffi/descriptor_pool.rb +3 -1
- data/lib/google/protobuf/ffi/enum_descriptor.rb +3 -1
- data/lib/google/protobuf/ffi/ffi.rb +0 -5
- data/lib/google/protobuf/ffi/field_descriptor.rb +4 -2
- data/lib/google/protobuf/ffi/file_descriptor.rb +3 -1
- data/lib/google/protobuf/ffi/internal/convert.rb +1 -1
- data/lib/google/protobuf/ffi/method_descriptor.rb +114 -0
- data/lib/google/protobuf/ffi/oneof_descriptor.rb +3 -1
- data/lib/google/protobuf/ffi/service_descriptor.rb +107 -0
- data/lib/google/protobuf/repeated_field.rb +3 -3
- data/lib/google/protobuf_ffi.rb +2 -0
- metadata +21 -5
@@ -113,17 +113,17 @@ Error, UINTPTR_MAX is undefined
|
|
113
113
|
|
114
114
|
// Macros for function attributes on compilers that support them.
|
115
115
|
#ifdef __GNUC__
|
116
|
-
#define UPB_FORCEINLINE __inline__ __attribute__((always_inline))
|
116
|
+
#define UPB_FORCEINLINE __inline__ __attribute__((always_inline)) static
|
117
117
|
#define UPB_NOINLINE __attribute__((noinline))
|
118
118
|
#define UPB_NORETURN __attribute__((__noreturn__))
|
119
119
|
#define UPB_PRINTF(str, first_vararg) __attribute__((format (printf, str, first_vararg)))
|
120
120
|
#elif defined(_MSC_VER)
|
121
121
|
#define UPB_NOINLINE
|
122
|
-
#define UPB_FORCEINLINE
|
122
|
+
#define UPB_FORCEINLINE static
|
123
123
|
#define UPB_NORETURN __declspec(noreturn)
|
124
124
|
#define UPB_PRINTF(str, first_vararg)
|
125
125
|
#else /* !defined(__GNUC__) */
|
126
|
-
#define UPB_FORCEINLINE
|
126
|
+
#define UPB_FORCEINLINE static
|
127
127
|
#define UPB_NOINLINE
|
128
128
|
#define UPB_NORETURN
|
129
129
|
#define UPB_PRINTF(str, first_vararg)
|
@@ -305,10 +305,10 @@ void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
|
|
305
305
|
|
306
306
|
/* Disable proto2 arena behavior (TEMPORARY) **********************************/
|
307
307
|
|
308
|
-
#ifdef
|
309
|
-
#define
|
308
|
+
#ifdef UPB_DISABLE_CLOSED_ENUM_CHECKING
|
309
|
+
#define UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN 1
|
310
310
|
#else
|
311
|
-
#define
|
311
|
+
#define UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN 0
|
312
312
|
#endif
|
313
313
|
|
314
314
|
#if defined(__cplusplus)
|
@@ -341,6 +341,12 @@ void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
|
|
341
341
|
#define UPB_DESC_MINITABLE(sym) &google__protobuf__##sym##_msg_init
|
342
342
|
#endif
|
343
343
|
|
344
|
+
#ifdef UPB_TRACING_ENABLED
|
345
|
+
#ifdef NDEBUG
|
346
|
+
error UPB_TRACING_ENABLED Tracing should be disabled in production builds
|
347
|
+
#endif
|
348
|
+
#endif
|
349
|
+
|
344
350
|
|
345
351
|
#include <errno.h>
|
346
352
|
#include <float.h>
|
@@ -416,6 +422,9 @@ const upb_MiniTable google__protobuf__FileDescriptorSet_msg_init = {
|
|
416
422
|
&google_protobuf_FileDescriptorSet_submsgs[0],
|
417
423
|
&google_protobuf_FileDescriptorSet__fields[0],
|
418
424
|
16, 1, kUpb_ExtMode_NonExtendable, 1, UPB_FASTTABLE_MASK(8), 0,
|
425
|
+
#ifdef UPB_TRACING_ENABLED
|
426
|
+
"google.protobuf.FileDescriptorSet",
|
427
|
+
#endif
|
419
428
|
UPB_FASTTABLE_INIT({
|
420
429
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
421
430
|
{0x000800003f00000a, &upb_prm_1bt_max192b},
|
@@ -452,6 +461,9 @@ const upb_MiniTable google__protobuf__FileDescriptorProto_msg_init = {
|
|
452
461
|
&google_protobuf_FileDescriptorProto_submsgs[0],
|
453
462
|
&google_protobuf_FileDescriptorProto__fields[0],
|
454
463
|
UPB_SIZE(80, 136), 13, kUpb_ExtMode_NonExtendable, 12, UPB_FASTTABLE_MASK(120), 0,
|
464
|
+
#ifdef UPB_TRACING_ENABLED
|
465
|
+
"google.protobuf.FileDescriptorProto",
|
466
|
+
#endif
|
455
467
|
UPB_FASTTABLE_INIT({
|
456
468
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
457
469
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -500,6 +512,9 @@ const upb_MiniTable google__protobuf__DescriptorProto_msg_init = {
|
|
500
512
|
&google_protobuf_DescriptorProto_submsgs[0],
|
501
513
|
&google_protobuf_DescriptorProto__fields[0],
|
502
514
|
UPB_SIZE(56, 104), 10, kUpb_ExtMode_NonExtendable, 10, UPB_FASTTABLE_MASK(120), 0,
|
515
|
+
#ifdef UPB_TRACING_ENABLED
|
516
|
+
"google.protobuf.DescriptorProto",
|
517
|
+
#endif
|
503
518
|
UPB_FASTTABLE_INIT({
|
504
519
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
505
520
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -534,6 +549,9 @@ const upb_MiniTable google__protobuf__DescriptorProto__ExtensionRange_msg_init =
|
|
534
549
|
&google_protobuf_DescriptorProto_ExtensionRange_submsgs[0],
|
535
550
|
&google_protobuf_DescriptorProto_ExtensionRange__fields[0],
|
536
551
|
UPB_SIZE(24, 32), 3, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(255), 0,
|
552
|
+
#ifdef UPB_TRACING_ENABLED
|
553
|
+
"google.protobuf.DescriptorProto.ExtensionRange",
|
554
|
+
#endif
|
537
555
|
};
|
538
556
|
|
539
557
|
static const upb_MiniTableField google_protobuf_DescriptorProto_ReservedRange__fields[2] = {
|
@@ -545,6 +563,9 @@ const upb_MiniTable google__protobuf__DescriptorProto__ReservedRange_msg_init =
|
|
545
563
|
NULL,
|
546
564
|
&google_protobuf_DescriptorProto_ReservedRange__fields[0],
|
547
565
|
24, 2, kUpb_ExtMode_NonExtendable, 2, UPB_FASTTABLE_MASK(255), 0,
|
566
|
+
#ifdef UPB_TRACING_ENABLED
|
567
|
+
"google.protobuf.DescriptorProto.ReservedRange",
|
568
|
+
#endif
|
548
569
|
};
|
549
570
|
|
550
571
|
static const upb_MiniTableSub google_protobuf_ExtensionRangeOptions_submsgs[4] = {
|
@@ -565,6 +586,9 @@ const upb_MiniTable google__protobuf__ExtensionRangeOptions_msg_init = {
|
|
565
586
|
&google_protobuf_ExtensionRangeOptions_submsgs[0],
|
566
587
|
&google_protobuf_ExtensionRangeOptions__fields[0],
|
567
588
|
UPB_SIZE(32, 40), 4, kUpb_ExtMode_Extendable, 0, UPB_FASTTABLE_MASK(248), 0,
|
589
|
+
#ifdef UPB_TRACING_ENABLED
|
590
|
+
"google.protobuf.ExtensionRangeOptions",
|
591
|
+
#endif
|
568
592
|
UPB_FASTTABLE_INIT({
|
569
593
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
570
594
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -613,6 +637,9 @@ const upb_MiniTable google__protobuf__ExtensionRangeOptions__Declaration_msg_ini
|
|
613
637
|
NULL,
|
614
638
|
&google_protobuf_ExtensionRangeOptions_Declaration__fields[0],
|
615
639
|
UPB_SIZE(40, 56), 5, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(255), 0,
|
640
|
+
#ifdef UPB_TRACING_ENABLED
|
641
|
+
"google.protobuf.ExtensionRangeOptions.Declaration",
|
642
|
+
#endif
|
616
643
|
};
|
617
644
|
|
618
645
|
static const upb_MiniTableSub google_protobuf_FieldDescriptorProto_submsgs[3] = {
|
@@ -639,6 +666,9 @@ const upb_MiniTable google__protobuf__FieldDescriptorProto_msg_init = {
|
|
639
666
|
&google_protobuf_FieldDescriptorProto_submsgs[0],
|
640
667
|
&google_protobuf_FieldDescriptorProto__fields[0],
|
641
668
|
UPB_SIZE(80, 120), 11, kUpb_ExtMode_NonExtendable, 10, UPB_FASTTABLE_MASK(255), 0,
|
669
|
+
#ifdef UPB_TRACING_ENABLED
|
670
|
+
"google.protobuf.FieldDescriptorProto",
|
671
|
+
#endif
|
642
672
|
};
|
643
673
|
|
644
674
|
static const upb_MiniTableSub google_protobuf_OneofDescriptorProto_submsgs[1] = {
|
@@ -654,6 +684,9 @@ const upb_MiniTable google__protobuf__OneofDescriptorProto_msg_init = {
|
|
654
684
|
&google_protobuf_OneofDescriptorProto_submsgs[0],
|
655
685
|
&google_protobuf_OneofDescriptorProto__fields[0],
|
656
686
|
UPB_SIZE(24, 40), 2, kUpb_ExtMode_NonExtendable, 2, UPB_FASTTABLE_MASK(255), 0,
|
687
|
+
#ifdef UPB_TRACING_ENABLED
|
688
|
+
"google.protobuf.OneofDescriptorProto",
|
689
|
+
#endif
|
657
690
|
};
|
658
691
|
|
659
692
|
static const upb_MiniTableSub google_protobuf_EnumDescriptorProto_submsgs[3] = {
|
@@ -674,6 +707,9 @@ const upb_MiniTable google__protobuf__EnumDescriptorProto_msg_init = {
|
|
674
707
|
&google_protobuf_EnumDescriptorProto_submsgs[0],
|
675
708
|
&google_protobuf_EnumDescriptorProto__fields[0],
|
676
709
|
UPB_SIZE(40, 64), 5, kUpb_ExtMode_NonExtendable, 5, UPB_FASTTABLE_MASK(56), 0,
|
710
|
+
#ifdef UPB_TRACING_ENABLED
|
711
|
+
"google.protobuf.EnumDescriptorProto",
|
712
|
+
#endif
|
677
713
|
UPB_FASTTABLE_INIT({
|
678
714
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
679
715
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -695,6 +731,9 @@ const upb_MiniTable google__protobuf__EnumDescriptorProto__EnumReservedRange_msg
|
|
695
731
|
NULL,
|
696
732
|
&google_protobuf_EnumDescriptorProto_EnumReservedRange__fields[0],
|
697
733
|
24, 2, kUpb_ExtMode_NonExtendable, 2, UPB_FASTTABLE_MASK(255), 0,
|
734
|
+
#ifdef UPB_TRACING_ENABLED
|
735
|
+
"google.protobuf.EnumDescriptorProto.EnumReservedRange",
|
736
|
+
#endif
|
698
737
|
};
|
699
738
|
|
700
739
|
static const upb_MiniTableSub google_protobuf_EnumValueDescriptorProto_submsgs[1] = {
|
@@ -711,6 +750,9 @@ const upb_MiniTable google__protobuf__EnumValueDescriptorProto_msg_init = {
|
|
711
750
|
&google_protobuf_EnumValueDescriptorProto_submsgs[0],
|
712
751
|
&google_protobuf_EnumValueDescriptorProto__fields[0],
|
713
752
|
UPB_SIZE(32, 40), 3, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(255), 0,
|
753
|
+
#ifdef UPB_TRACING_ENABLED
|
754
|
+
"google.protobuf.EnumValueDescriptorProto",
|
755
|
+
#endif
|
714
756
|
};
|
715
757
|
|
716
758
|
static const upb_MiniTableSub google_protobuf_ServiceDescriptorProto_submsgs[2] = {
|
@@ -728,6 +770,9 @@ const upb_MiniTable google__protobuf__ServiceDescriptorProto_msg_init = {
|
|
728
770
|
&google_protobuf_ServiceDescriptorProto_submsgs[0],
|
729
771
|
&google_protobuf_ServiceDescriptorProto__fields[0],
|
730
772
|
UPB_SIZE(32, 48), 3, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(24), 0,
|
773
|
+
#ifdef UPB_TRACING_ENABLED
|
774
|
+
"google.protobuf.ServiceDescriptorProto",
|
775
|
+
#endif
|
731
776
|
UPB_FASTTABLE_INIT({
|
732
777
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
733
778
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -753,6 +798,9 @@ const upb_MiniTable google__protobuf__MethodDescriptorProto_msg_init = {
|
|
753
798
|
&google_protobuf_MethodDescriptorProto_submsgs[0],
|
754
799
|
&google_protobuf_MethodDescriptorProto__fields[0],
|
755
800
|
UPB_SIZE(48, 72), 6, kUpb_ExtMode_NonExtendable, 6, UPB_FASTTABLE_MASK(255), 0,
|
801
|
+
#ifdef UPB_TRACING_ENABLED
|
802
|
+
"google.protobuf.MethodDescriptorProto",
|
803
|
+
#endif
|
756
804
|
};
|
757
805
|
|
758
806
|
static const upb_MiniTableSub google_protobuf_FileOptions_submsgs[3] = {
|
@@ -789,6 +837,9 @@ const upb_MiniTable google__protobuf__FileOptions_msg_init = {
|
|
789
837
|
&google_protobuf_FileOptions_submsgs[0],
|
790
838
|
&google_protobuf_FileOptions__fields[0],
|
791
839
|
UPB_SIZE(112, 200), 21, kUpb_ExtMode_Extendable, 1, UPB_FASTTABLE_MASK(248), 0,
|
840
|
+
#ifdef UPB_TRACING_ENABLED
|
841
|
+
"google.protobuf.FileOptions",
|
842
|
+
#endif
|
792
843
|
UPB_FASTTABLE_INIT({
|
793
844
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
794
845
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -844,6 +895,9 @@ const upb_MiniTable google__protobuf__MessageOptions_msg_init = {
|
|
844
895
|
&google_protobuf_MessageOptions_submsgs[0],
|
845
896
|
&google_protobuf_MessageOptions__fields[0],
|
846
897
|
UPB_SIZE(24, 32), 7, kUpb_ExtMode_Extendable, 3, UPB_FASTTABLE_MASK(248), 0,
|
898
|
+
#ifdef UPB_TRACING_ENABLED
|
899
|
+
"google.protobuf.MessageOptions",
|
900
|
+
#endif
|
847
901
|
UPB_FASTTABLE_INIT({
|
848
902
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
849
903
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -880,9 +934,10 @@ const upb_MiniTable google__protobuf__MessageOptions_msg_init = {
|
|
880
934
|
})
|
881
935
|
};
|
882
936
|
|
883
|
-
static const upb_MiniTableSub google_protobuf_FieldOptions_submsgs[
|
937
|
+
static const upb_MiniTableSub google_protobuf_FieldOptions_submsgs[8] = {
|
884
938
|
{.UPB_PRIVATE(submsg) = &google__protobuf__FieldOptions__EditionDefault_msg_init},
|
885
939
|
{.UPB_PRIVATE(submsg) = &google__protobuf__FeatureSet_msg_init},
|
940
|
+
{.UPB_PRIVATE(submsg) = &google__protobuf__FieldOptions__FeatureSupport_msg_init},
|
886
941
|
{.UPB_PRIVATE(submsg) = &google__protobuf__UninterpretedOption_msg_init},
|
887
942
|
{.UPB_PRIVATE(subenum) = &google_protobuf_FieldOptions_CType_enum_init},
|
888
943
|
{.UPB_PRIVATE(subenum) = &google_protobuf_FieldOptions_JSType_enum_init},
|
@@ -890,26 +945,30 @@ static const upb_MiniTableSub google_protobuf_FieldOptions_submsgs[7] = {
|
|
890
945
|
{.UPB_PRIVATE(subenum) = &google_protobuf_FieldOptions_OptionTargetType_enum_init},
|
891
946
|
};
|
892
947
|
|
893
|
-
static const upb_MiniTableField google_protobuf_FieldOptions__fields[
|
894
|
-
{1, 12, 64,
|
948
|
+
static const upb_MiniTableField google_protobuf_FieldOptions__fields[14] = {
|
949
|
+
{1, 12, 64, 4, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
|
895
950
|
{2, 16, 65, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
|
896
951
|
{3, 17, 66, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
|
897
952
|
{5, 18, 67, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
|
898
|
-
{6, 20, 68,
|
953
|
+
{6, 20, 68, 5, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
|
899
954
|
{10, 24, 69, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
|
900
955
|
{15, 25, 70, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
|
901
956
|
{16, 26, 71, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
|
902
|
-
{17, 28, 72,
|
903
|
-
{19, 32, 0,
|
957
|
+
{17, 28, 72, 6, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
|
958
|
+
{19, 32, 0, 7, 14, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
|
904
959
|
{20, UPB_SIZE(36, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
|
905
960
|
{21, UPB_SIZE(40, 48), 73, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
|
906
|
-
{
|
961
|
+
{22, UPB_SIZE(44, 56), 74, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
|
962
|
+
{999, UPB_SIZE(48, 64), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
|
907
963
|
};
|
908
964
|
|
909
965
|
const upb_MiniTable google__protobuf__FieldOptions_msg_init = {
|
910
966
|
&google_protobuf_FieldOptions_submsgs[0],
|
911
967
|
&google_protobuf_FieldOptions__fields[0],
|
912
|
-
UPB_SIZE(
|
968
|
+
UPB_SIZE(56, 72), 14, kUpb_ExtMode_Extendable, 3, UPB_FASTTABLE_MASK(248), 0,
|
969
|
+
#ifdef UPB_TRACING_ENABLED
|
970
|
+
"google.protobuf.FieldOptions",
|
971
|
+
#endif
|
913
972
|
UPB_FASTTABLE_INIT({
|
914
973
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
915
974
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -934,7 +993,7 @@ const upb_MiniTable google__protobuf__FieldOptions_msg_init = {
|
|
934
993
|
{0x002800003f0001a2, &upb_prm_2bt_max64b},
|
935
994
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
936
995
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
937
|
-
{
|
996
|
+
{0x004000003f033eba, &upb_prm_2bt_max128b},
|
938
997
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
939
998
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
940
999
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -959,6 +1018,31 @@ const upb_MiniTable google__protobuf__FieldOptions__EditionDefault_msg_init = {
|
|
959
1018
|
&google_protobuf_FieldOptions_EditionDefault_submsgs[0],
|
960
1019
|
&google_protobuf_FieldOptions_EditionDefault__fields[0],
|
961
1020
|
UPB_SIZE(24, 32), 2, kUpb_ExtMode_NonExtendable, 0, UPB_FASTTABLE_MASK(255), 0,
|
1021
|
+
#ifdef UPB_TRACING_ENABLED
|
1022
|
+
"google.protobuf.FieldOptions.EditionDefault",
|
1023
|
+
#endif
|
1024
|
+
};
|
1025
|
+
|
1026
|
+
static const upb_MiniTableSub google_protobuf_FieldOptions_FeatureSupport_submsgs[3] = {
|
1027
|
+
{.UPB_PRIVATE(subenum) = &google_protobuf_Edition_enum_init},
|
1028
|
+
{.UPB_PRIVATE(subenum) = &google_protobuf_Edition_enum_init},
|
1029
|
+
{.UPB_PRIVATE(subenum) = &google_protobuf_Edition_enum_init},
|
1030
|
+
};
|
1031
|
+
|
1032
|
+
static const upb_MiniTableField google_protobuf_FieldOptions_FeatureSupport__fields[4] = {
|
1033
|
+
{1, 12, 64, 0, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
|
1034
|
+
{2, 16, 65, 1, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
|
1035
|
+
{3, 24, 66, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
|
1036
|
+
{4, 20, 67, 2, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
|
1037
|
+
};
|
1038
|
+
|
1039
|
+
const upb_MiniTable google__protobuf__FieldOptions__FeatureSupport_msg_init = {
|
1040
|
+
&google_protobuf_FieldOptions_FeatureSupport_submsgs[0],
|
1041
|
+
&google_protobuf_FieldOptions_FeatureSupport__fields[0],
|
1042
|
+
UPB_SIZE(32, 40), 4, kUpb_ExtMode_NonExtendable, 4, UPB_FASTTABLE_MASK(255), 0,
|
1043
|
+
#ifdef UPB_TRACING_ENABLED
|
1044
|
+
"google.protobuf.FieldOptions.FeatureSupport",
|
1045
|
+
#endif
|
962
1046
|
};
|
963
1047
|
|
964
1048
|
static const upb_MiniTableSub google_protobuf_OneofOptions_submsgs[2] = {
|
@@ -975,6 +1059,9 @@ const upb_MiniTable google__protobuf__OneofOptions_msg_init = {
|
|
975
1059
|
&google_protobuf_OneofOptions_submsgs[0],
|
976
1060
|
&google_protobuf_OneofOptions__fields[0],
|
977
1061
|
UPB_SIZE(24, 32), 2, kUpb_ExtMode_Extendable, 1, UPB_FASTTABLE_MASK(248), 0,
|
1062
|
+
#ifdef UPB_TRACING_ENABLED
|
1063
|
+
"google.protobuf.OneofOptions",
|
1064
|
+
#endif
|
978
1065
|
UPB_FASTTABLE_INIT({
|
979
1066
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
980
1067
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -1028,6 +1115,9 @@ const upb_MiniTable google__protobuf__EnumOptions_msg_init = {
|
|
1028
1115
|
&google_protobuf_EnumOptions_submsgs[0],
|
1029
1116
|
&google_protobuf_EnumOptions__fields[0],
|
1030
1117
|
UPB_SIZE(24, 32), 5, kUpb_ExtMode_Extendable, 0, UPB_FASTTABLE_MASK(248), 0,
|
1118
|
+
#ifdef UPB_TRACING_ENABLED
|
1119
|
+
"google.protobuf.EnumOptions",
|
1120
|
+
#endif
|
1031
1121
|
UPB_FASTTABLE_INIT({
|
1032
1122
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
1033
1123
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -1080,6 +1170,9 @@ const upb_MiniTable google__protobuf__EnumValueOptions_msg_init = {
|
|
1080
1170
|
&google_protobuf_EnumValueOptions_submsgs[0],
|
1081
1171
|
&google_protobuf_EnumValueOptions__fields[0],
|
1082
1172
|
UPB_SIZE(24, 32), 4, kUpb_ExtMode_Extendable, 3, UPB_FASTTABLE_MASK(248), 0,
|
1173
|
+
#ifdef UPB_TRACING_ENABLED
|
1174
|
+
"google.protobuf.EnumValueOptions",
|
1175
|
+
#endif
|
1083
1176
|
UPB_FASTTABLE_INIT({
|
1084
1177
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
1085
1178
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -1131,6 +1224,9 @@ const upb_MiniTable google__protobuf__ServiceOptions_msg_init = {
|
|
1131
1224
|
&google_protobuf_ServiceOptions_submsgs[0],
|
1132
1225
|
&google_protobuf_ServiceOptions__fields[0],
|
1133
1226
|
UPB_SIZE(24, 32), 3, kUpb_ExtMode_Extendable, 0, UPB_FASTTABLE_MASK(248), 0,
|
1227
|
+
#ifdef UPB_TRACING_ENABLED
|
1228
|
+
"google.protobuf.ServiceOptions",
|
1229
|
+
#endif
|
1134
1230
|
UPB_FASTTABLE_INIT({
|
1135
1231
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
1136
1232
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -1184,6 +1280,9 @@ const upb_MiniTable google__protobuf__MethodOptions_msg_init = {
|
|
1184
1280
|
&google_protobuf_MethodOptions_submsgs[0],
|
1185
1281
|
&google_protobuf_MethodOptions__fields[0],
|
1186
1282
|
UPB_SIZE(24, 32), 4, kUpb_ExtMode_Extendable, 0, UPB_FASTTABLE_MASK(248), 0,
|
1283
|
+
#ifdef UPB_TRACING_ENABLED
|
1284
|
+
"google.protobuf.MethodOptions",
|
1285
|
+
#endif
|
1187
1286
|
UPB_FASTTABLE_INIT({
|
1188
1287
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
1189
1288
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -1238,6 +1337,9 @@ const upb_MiniTable google__protobuf__UninterpretedOption_msg_init = {
|
|
1238
1337
|
&google_protobuf_UninterpretedOption_submsgs[0],
|
1239
1338
|
&google_protobuf_UninterpretedOption__fields[0],
|
1240
1339
|
UPB_SIZE(64, 96), 7, kUpb_ExtMode_NonExtendable, 0, UPB_FASTTABLE_MASK(24), 0,
|
1340
|
+
#ifdef UPB_TRACING_ENABLED
|
1341
|
+
"google.protobuf.UninterpretedOption",
|
1342
|
+
#endif
|
1241
1343
|
UPB_FASTTABLE_INIT({
|
1242
1344
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
1243
1345
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
@@ -1255,6 +1357,9 @@ const upb_MiniTable google__protobuf__UninterpretedOption__NamePart_msg_init = {
|
|
1255
1357
|
NULL,
|
1256
1358
|
&google_protobuf_UninterpretedOption_NamePart__fields[0],
|
1257
1359
|
UPB_SIZE(24, 32), 2, kUpb_ExtMode_NonExtendable, 2, UPB_FASTTABLE_MASK(255), 2,
|
1360
|
+
#ifdef UPB_TRACING_ENABLED
|
1361
|
+
"google.protobuf.UninterpretedOption.NamePart",
|
1362
|
+
#endif
|
1258
1363
|
};
|
1259
1364
|
|
1260
1365
|
static const upb_MiniTableSub google_protobuf_FeatureSet_submsgs[6] = {
|
@@ -1279,6 +1384,9 @@ const upb_MiniTable google__protobuf__FeatureSet_msg_init = {
|
|
1279
1384
|
&google_protobuf_FeatureSet_submsgs[0],
|
1280
1385
|
&google_protobuf_FeatureSet__fields[0],
|
1281
1386
|
40, 6, kUpb_ExtMode_Extendable, 6, UPB_FASTTABLE_MASK(255), 0,
|
1387
|
+
#ifdef UPB_TRACING_ENABLED
|
1388
|
+
"google.protobuf.FeatureSet",
|
1389
|
+
#endif
|
1282
1390
|
};
|
1283
1391
|
|
1284
1392
|
static const upb_MiniTableSub google_protobuf_FeatureSetDefaults_submsgs[3] = {
|
@@ -1297,26 +1405,34 @@ const upb_MiniTable google__protobuf__FeatureSetDefaults_msg_init = {
|
|
1297
1405
|
&google_protobuf_FeatureSetDefaults_submsgs[0],
|
1298
1406
|
&google_protobuf_FeatureSetDefaults__fields[0],
|
1299
1407
|
UPB_SIZE(24, 32), 3, kUpb_ExtMode_NonExtendable, 1, UPB_FASTTABLE_MASK(8), 0,
|
1408
|
+
#ifdef UPB_TRACING_ENABLED
|
1409
|
+
"google.protobuf.FeatureSetDefaults",
|
1410
|
+
#endif
|
1300
1411
|
UPB_FASTTABLE_INIT({
|
1301
1412
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
1302
1413
|
{0x001800003f00000a, &upb_prm_1bt_max64b},
|
1303
1414
|
})
|
1304
1415
|
};
|
1305
1416
|
|
1306
|
-
static const upb_MiniTableSub google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_submsgs[
|
1417
|
+
static const upb_MiniTableSub google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_submsgs[3] = {
|
1418
|
+
{.UPB_PRIVATE(submsg) = &google__protobuf__FeatureSet_msg_init},
|
1307
1419
|
{.UPB_PRIVATE(submsg) = &google__protobuf__FeatureSet_msg_init},
|
1308
1420
|
{.UPB_PRIVATE(subenum) = &google_protobuf_Edition_enum_init},
|
1309
1421
|
};
|
1310
1422
|
|
1311
|
-
static const upb_MiniTableField google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault__fields[
|
1312
|
-
{
|
1313
|
-
{
|
1423
|
+
static const upb_MiniTableField google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault__fields[3] = {
|
1424
|
+
{3, 12, 64, 2, 14, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
|
1425
|
+
{4, 16, 65, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
|
1426
|
+
{5, UPB_SIZE(20, 24), 66, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
|
1314
1427
|
};
|
1315
1428
|
|
1316
1429
|
const upb_MiniTable google__protobuf__FeatureSetDefaults__FeatureSetEditionDefault_msg_init = {
|
1317
1430
|
&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_submsgs[0],
|
1318
1431
|
&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault__fields[0],
|
1319
|
-
24,
|
1432
|
+
UPB_SIZE(24, 32), 3, kUpb_ExtMode_NonExtendable, 0, UPB_FASTTABLE_MASK(255), 0,
|
1433
|
+
#ifdef UPB_TRACING_ENABLED
|
1434
|
+
"google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault",
|
1435
|
+
#endif
|
1320
1436
|
};
|
1321
1437
|
|
1322
1438
|
static const upb_MiniTableSub google_protobuf_SourceCodeInfo_submsgs[1] = {
|
@@ -1331,6 +1447,9 @@ const upb_MiniTable google__protobuf__SourceCodeInfo_msg_init = {
|
|
1331
1447
|
&google_protobuf_SourceCodeInfo_submsgs[0],
|
1332
1448
|
&google_protobuf_SourceCodeInfo__fields[0],
|
1333
1449
|
16, 1, kUpb_ExtMode_NonExtendable, 1, UPB_FASTTABLE_MASK(8), 0,
|
1450
|
+
#ifdef UPB_TRACING_ENABLED
|
1451
|
+
"google.protobuf.SourceCodeInfo",
|
1452
|
+
#endif
|
1334
1453
|
UPB_FASTTABLE_INIT({
|
1335
1454
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
1336
1455
|
{0x000800003f00000a, &upb_prm_1bt_max128b},
|
@@ -1349,6 +1468,9 @@ const upb_MiniTable google__protobuf__SourceCodeInfo__Location_msg_init = {
|
|
1349
1468
|
NULL,
|
1350
1469
|
&google_protobuf_SourceCodeInfo_Location__fields[0],
|
1351
1470
|
UPB_SIZE(40, 72), 5, kUpb_ExtMode_NonExtendable, 4, UPB_FASTTABLE_MASK(56), 0,
|
1471
|
+
#ifdef UPB_TRACING_ENABLED
|
1472
|
+
"google.protobuf.SourceCodeInfo.Location",
|
1473
|
+
#endif
|
1352
1474
|
UPB_FASTTABLE_INIT({
|
1353
1475
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
1354
1476
|
{0x001000003f00000a, &upb_ppv4_1bt},
|
@@ -1373,6 +1495,9 @@ const upb_MiniTable google__protobuf__GeneratedCodeInfo_msg_init = {
|
|
1373
1495
|
&google_protobuf_GeneratedCodeInfo_submsgs[0],
|
1374
1496
|
&google_protobuf_GeneratedCodeInfo__fields[0],
|
1375
1497
|
16, 1, kUpb_ExtMode_NonExtendable, 1, UPB_FASTTABLE_MASK(8), 0,
|
1498
|
+
#ifdef UPB_TRACING_ENABLED
|
1499
|
+
"google.protobuf.GeneratedCodeInfo",
|
1500
|
+
#endif
|
1376
1501
|
UPB_FASTTABLE_INIT({
|
1377
1502
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
1378
1503
|
{0x000800003f00000a, &upb_prm_1bt_max64b},
|
@@ -1395,13 +1520,16 @@ const upb_MiniTable google__protobuf__GeneratedCodeInfo__Annotation_msg_init = {
|
|
1395
1520
|
&google_protobuf_GeneratedCodeInfo_Annotation_submsgs[0],
|
1396
1521
|
&google_protobuf_GeneratedCodeInfo_Annotation__fields[0],
|
1397
1522
|
UPB_SIZE(40, 48), 5, kUpb_ExtMode_NonExtendable, 5, UPB_FASTTABLE_MASK(8), 0,
|
1523
|
+
#ifdef UPB_TRACING_ENABLED
|
1524
|
+
"google.protobuf.GeneratedCodeInfo.Annotation",
|
1525
|
+
#endif
|
1398
1526
|
UPB_FASTTABLE_INIT({
|
1399
1527
|
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
|
1400
1528
|
{0x001800003f00000a, &upb_ppv4_1bt},
|
1401
1529
|
})
|
1402
1530
|
};
|
1403
1531
|
|
1404
|
-
static const upb_MiniTable *messages_layout[
|
1532
|
+
static const upb_MiniTable *messages_layout[33] = {
|
1405
1533
|
&google__protobuf__FileDescriptorSet_msg_init,
|
1406
1534
|
&google__protobuf__FileDescriptorProto_msg_init,
|
1407
1535
|
&google__protobuf__DescriptorProto_msg_init,
|
@@ -1420,6 +1548,7 @@ static const upb_MiniTable *messages_layout[32] = {
|
|
1420
1548
|
&google__protobuf__MessageOptions_msg_init,
|
1421
1549
|
&google__protobuf__FieldOptions_msg_init,
|
1422
1550
|
&google__protobuf__FieldOptions__EditionDefault_msg_init,
|
1551
|
+
&google__protobuf__FieldOptions__FeatureSupport_msg_init,
|
1423
1552
|
&google__protobuf__OneofOptions_msg_init,
|
1424
1553
|
&google__protobuf__EnumOptions_msg_init,
|
1425
1554
|
&google__protobuf__EnumValueOptions_msg_init,
|
@@ -1438,10 +1567,11 @@ static const upb_MiniTable *messages_layout[32] = {
|
|
1438
1567
|
|
1439
1568
|
const upb_MiniTableEnum google_protobuf_Edition_enum_init = {
|
1440
1569
|
64,
|
1441
|
-
|
1570
|
+
9,
|
1442
1571
|
{
|
1443
1572
|
0x7,
|
1444
1573
|
0x0,
|
1574
|
+
0x384,
|
1445
1575
|
0x3e6,
|
1446
1576
|
0x3e7,
|
1447
1577
|
0x3e8,
|
@@ -1621,7 +1751,7 @@ const upb_MiniTableFile google_protobuf_descriptor_proto_upb_file_layout = {
|
|
1621
1751
|
messages_layout,
|
1622
1752
|
enums_layout,
|
1623
1753
|
NULL,
|
1624
|
-
|
1754
|
+
33,
|
1625
1755
|
17,
|
1626
1756
|
0,
|
1627
1757
|
};
|
@@ -3131,6 +3261,7 @@ static bool upb_JsonDecoder_Decode(jsondec* const d, upb_Message* const msg,
|
|
3131
3261
|
bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg,
|
3132
3262
|
const upb_MessageDef* m, const upb_DefPool* symtab,
|
3133
3263
|
int options, upb_Arena* arena, upb_Status* status) {
|
3264
|
+
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
3134
3265
|
jsondec d;
|
3135
3266
|
|
3136
3267
|
if (size == 0) return true;
|
@@ -3941,6 +4072,10 @@ static void* upb_global_allocfunc(upb_alloc* alloc, void* ptr, size_t oldsize,
|
|
3941
4072
|
upb_alloc upb_alloc_global = {&upb_global_allocfunc};
|
3942
4073
|
|
3943
4074
|
|
4075
|
+
#ifdef UPB_TRACING_ENABLED
|
4076
|
+
#include <stdatomic.h>
|
4077
|
+
#endif
|
4078
|
+
|
3944
4079
|
#include <stddef.h>
|
3945
4080
|
#include <stdint.h>
|
3946
4081
|
|
@@ -4047,6 +4182,38 @@ static bool _upb_ArenaInternal_HasInitialBlock(upb_ArenaInternal* ai) {
|
|
4047
4182
|
return ai->block_alloc & 0x1;
|
4048
4183
|
}
|
4049
4184
|
|
4185
|
+
#ifdef UPB_TRACING_ENABLED
|
4186
|
+
static void (*_init_arena_trace_handler)(const upb_Arena*, size_t size) = NULL;
|
4187
|
+
static void (*_fuse_arena_trace_handler)(const upb_Arena*,
|
4188
|
+
const upb_Arena*) = NULL;
|
4189
|
+
static void (*_free_arena_trace_handler)(const upb_Arena*) = NULL;
|
4190
|
+
|
4191
|
+
void upb_Arena_SetTraceHandler(
|
4192
|
+
void (*initArenaTraceHandler)(const upb_Arena*, size_t size),
|
4193
|
+
void (*fuseArenaTraceHandler)(const upb_Arena*, const upb_Arena*),
|
4194
|
+
void (*freeArenaTraceHandler)(const upb_Arena*)) {
|
4195
|
+
_init_arena_trace_handler = initArenaTraceHandler;
|
4196
|
+
_fuse_arena_trace_handler = fuseArenaTraceHandler;
|
4197
|
+
_free_arena_trace_handler = freeArenaTraceHandler;
|
4198
|
+
}
|
4199
|
+
|
4200
|
+
void upb_Arena_LogInit(const upb_Arena* arena, size_t size) {
|
4201
|
+
if (_init_arena_trace_handler) {
|
4202
|
+
_init_arena_trace_handler(arena, size);
|
4203
|
+
}
|
4204
|
+
}
|
4205
|
+
void upb_Arena_LogFuse(const upb_Arena* arena1, const upb_Arena* arena2) {
|
4206
|
+
if (_fuse_arena_trace_handler) {
|
4207
|
+
_fuse_arena_trace_handler(arena1, arena2);
|
4208
|
+
}
|
4209
|
+
}
|
4210
|
+
void upb_Arena_LogFree(const upb_Arena* arena) {
|
4211
|
+
if (_free_arena_trace_handler) {
|
4212
|
+
_free_arena_trace_handler(arena);
|
4213
|
+
}
|
4214
|
+
}
|
4215
|
+
#endif // UPB_TRACING_ENABLED
|
4216
|
+
|
4050
4217
|
static upb_ArenaRoot _upb_Arena_FindRoot(upb_Arena* a) {
|
4051
4218
|
upb_ArenaInternal* ai = upb_Arena_Internal(a);
|
4052
4219
|
uintptr_t poc = upb_Atomic_Load(&ai->parent_or_count, memory_order_acquire);
|
@@ -4104,6 +4271,21 @@ size_t upb_Arena_SpaceAllocated(upb_Arena* arena, size_t* fused_count) {
|
|
4104
4271
|
return memsize;
|
4105
4272
|
}
|
4106
4273
|
|
4274
|
+
bool UPB_PRIVATE(_upb_Arena_Contains)(const upb_Arena* a, void* ptr) {
|
4275
|
+
upb_ArenaInternal* ai = upb_Arena_Internal(a);
|
4276
|
+
UPB_ASSERT(ai);
|
4277
|
+
|
4278
|
+
upb_MemBlock* block = upb_Atomic_Load(&ai->blocks, memory_order_relaxed);
|
4279
|
+
while (block) {
|
4280
|
+
uintptr_t beg = (uintptr_t)block;
|
4281
|
+
uintptr_t end = beg + block->size;
|
4282
|
+
if ((uintptr_t)ptr >= beg && (uintptr_t)ptr < end) return true;
|
4283
|
+
block = upb_Atomic_Load(&block->next, memory_order_relaxed);
|
4284
|
+
}
|
4285
|
+
|
4286
|
+
return false;
|
4287
|
+
}
|
4288
|
+
|
4107
4289
|
uint32_t upb_Arena_DebugRefCount(upb_Arena* a) {
|
4108
4290
|
upb_ArenaInternal* ai = upb_Arena_Internal(a);
|
4109
4291
|
// These loads could probably be relaxed, but given that this is debug-only,
|
@@ -4195,7 +4377,13 @@ upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc) {
|
|
4195
4377
|
n = UPB_ALIGN_DOWN(n, UPB_ALIGN_OF(upb_ArenaState));
|
4196
4378
|
|
4197
4379
|
if (UPB_UNLIKELY(n < sizeof(upb_ArenaState))) {
|
4380
|
+
#ifdef UPB_TRACING_ENABLED
|
4381
|
+
upb_Arena* ret = _upb_Arena_InitSlow(alloc);
|
4382
|
+
upb_Arena_LogInit(ret, n);
|
4383
|
+
return ret;
|
4384
|
+
#else
|
4198
4385
|
return _upb_Arena_InitSlow(alloc);
|
4386
|
+
#endif
|
4199
4387
|
}
|
4200
4388
|
|
4201
4389
|
a = UPB_PTR_AT(mem, n - sizeof(upb_ArenaState), upb_ArenaState);
|
@@ -4208,13 +4396,14 @@ upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc) {
|
|
4208
4396
|
a->body.block_alloc = _upb_Arena_MakeBlockAlloc(alloc, 1);
|
4209
4397
|
a->head.UPB_PRIVATE(ptr) = mem;
|
4210
4398
|
a->head.UPB_PRIVATE(end) = UPB_PTR_AT(mem, n - sizeof(upb_ArenaState), char);
|
4211
|
-
|
4399
|
+
#ifdef UPB_TRACING_ENABLED
|
4400
|
+
upb_Arena_LogInit(&a->head, n);
|
4401
|
+
#endif
|
4212
4402
|
return &a->head;
|
4213
4403
|
}
|
4214
4404
|
|
4215
4405
|
static void _upb_Arena_DoFree(upb_ArenaInternal* ai) {
|
4216
4406
|
UPB_ASSERT(_upb_Arena_RefCountFromTagged(ai->parent_or_count) == 1);
|
4217
|
-
|
4218
4407
|
while (ai != NULL) {
|
4219
4408
|
// Load first since arena itself is likely from one of its blocks.
|
4220
4409
|
upb_ArenaInternal* next_arena =
|
@@ -4245,6 +4434,9 @@ retry:
|
|
4245
4434
|
// expensive then direct loads. As an optimization, we only do RMW ops
|
4246
4435
|
// when we need to update things for other threads to see.
|
4247
4436
|
if (poc == _upb_Arena_TaggedFromRefcount(1)) {
|
4437
|
+
#ifdef UPB_TRACING_ENABLED
|
4438
|
+
upb_Arena_LogFree(a);
|
4439
|
+
#endif
|
4248
4440
|
_upb_Arena_DoFree(ai);
|
4249
4441
|
return;
|
4250
4442
|
}
|
@@ -4364,6 +4556,10 @@ static bool _upb_Arena_FixupRefs(upb_ArenaInternal* new_root,
|
|
4364
4556
|
bool upb_Arena_Fuse(upb_Arena* a1, upb_Arena* a2) {
|
4365
4557
|
if (a1 == a2) return true; // trivial fuse
|
4366
4558
|
|
4559
|
+
#ifdef UPB_TRACING_ENABLED
|
4560
|
+
upb_Arena_LogFuse(a1, a2);
|
4561
|
+
#endif
|
4562
|
+
|
4367
4563
|
upb_ArenaInternal* ai1 = upb_Arena_Internal(a1);
|
4368
4564
|
upb_ArenaInternal* ai2 = upb_Arena_Internal(a2);
|
4369
4565
|
|
@@ -4430,18 +4626,19 @@ void UPB_PRIVATE(_upb_Arena_SwapOut)(upb_Arena* des, const upb_Arena* src) {
|
|
4430
4626
|
|
4431
4627
|
// Must be last.
|
4432
4628
|
|
4433
|
-
bool upb_Message_SetMapEntry(upb_Map* map, const upb_MiniTable*
|
4629
|
+
bool upb_Message_SetMapEntry(upb_Map* map, const upb_MiniTable* m,
|
4434
4630
|
const upb_MiniTableField* f,
|
4435
4631
|
upb_Message* map_entry_message, upb_Arena* arena) {
|
4632
|
+
UPB_ASSERT(!upb_Message_IsFrozen(map_entry_message));
|
4633
|
+
|
4436
4634
|
// TODO: use a variant of upb_MiniTable_GetSubMessageTable() here.
|
4437
4635
|
const upb_MiniTable* map_entry_mini_table = upb_MiniTableSub_Message(
|
4438
|
-
|
4636
|
+
m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
|
4439
4637
|
UPB_ASSERT(map_entry_mini_table);
|
4440
|
-
UPB_ASSERT(map_entry_mini_table->UPB_PRIVATE(field_count) == 2);
|
4441
4638
|
const upb_MiniTableField* map_entry_key_field =
|
4442
|
-
|
4639
|
+
upb_MiniTable_MapKey(map_entry_mini_table);
|
4443
4640
|
const upb_MiniTableField* map_entry_value_field =
|
4444
|
-
|
4641
|
+
upb_MiniTable_MapValue(map_entry_mini_table);
|
4445
4642
|
// Map key/value cannot have explicit defaults,
|
4446
4643
|
// hence assuming a zero default is valid.
|
4447
4644
|
upb_MessageValue default_val;
|
@@ -4466,31 +4663,33 @@ upb_Array* upb_Array_New(upb_Arena* a, upb_CType type) {
|
|
4466
4663
|
}
|
4467
4664
|
|
4468
4665
|
upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i) {
|
4666
|
+
UPB_ASSERT(i < upb_Array_Size(arr));
|
4469
4667
|
upb_MessageValue ret;
|
4470
4668
|
const char* data = upb_Array_DataPtr(arr);
|
4471
4669
|
const int lg2 = UPB_PRIVATE(_upb_Array_ElemSizeLg2)(arr);
|
4472
|
-
UPB_ASSERT(i < arr->UPB_PRIVATE(size));
|
4473
4670
|
memcpy(&ret, data + (i << lg2), 1 << lg2);
|
4474
4671
|
return ret;
|
4475
4672
|
}
|
4476
4673
|
|
4477
4674
|
upb_MutableMessageValue upb_Array_GetMutable(upb_Array* arr, size_t i) {
|
4675
|
+
UPB_ASSERT(i < upb_Array_Size(arr));
|
4478
4676
|
upb_MutableMessageValue ret;
|
4479
4677
|
char* data = upb_Array_MutableDataPtr(arr);
|
4480
4678
|
const int lg2 = UPB_PRIVATE(_upb_Array_ElemSizeLg2)(arr);
|
4481
|
-
UPB_ASSERT(i < arr->UPB_PRIVATE(size));
|
4482
4679
|
memcpy(&ret, data + (i << lg2), 1 << lg2);
|
4483
4680
|
return ret;
|
4484
4681
|
}
|
4485
4682
|
|
4486
4683
|
void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val) {
|
4684
|
+
UPB_ASSERT(!upb_Array_IsFrozen(arr));
|
4685
|
+
UPB_ASSERT(i < upb_Array_Size(arr));
|
4487
4686
|
char* data = upb_Array_MutableDataPtr(arr);
|
4488
4687
|
const int lg2 = UPB_PRIVATE(_upb_Array_ElemSizeLg2)(arr);
|
4489
|
-
UPB_ASSERT(i < arr->UPB_PRIVATE(size));
|
4490
4688
|
memcpy(data + (i << lg2), &val, 1 << lg2);
|
4491
4689
|
}
|
4492
4690
|
|
4493
4691
|
bool upb_Array_Append(upb_Array* arr, upb_MessageValue val, upb_Arena* arena) {
|
4692
|
+
UPB_ASSERT(!upb_Array_IsFrozen(arr));
|
4494
4693
|
UPB_ASSERT(arena);
|
4495
4694
|
if (!UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
|
4496
4695
|
arr, arr->UPB_PRIVATE(size) + 1, arena)) {
|
@@ -4502,6 +4701,7 @@ bool upb_Array_Append(upb_Array* arr, upb_MessageValue val, upb_Arena* arena) {
|
|
4502
4701
|
|
4503
4702
|
void upb_Array_Move(upb_Array* arr, size_t dst_idx, size_t src_idx,
|
4504
4703
|
size_t count) {
|
4704
|
+
UPB_ASSERT(!upb_Array_IsFrozen(arr));
|
4505
4705
|
const int lg2 = UPB_PRIVATE(_upb_Array_ElemSizeLg2)(arr);
|
4506
4706
|
char* data = upb_Array_MutableDataPtr(arr);
|
4507
4707
|
memmove(&data[dst_idx << lg2], &data[src_idx << lg2], count << lg2);
|
@@ -4509,6 +4709,7 @@ void upb_Array_Move(upb_Array* arr, size_t dst_idx, size_t src_idx,
|
|
4509
4709
|
|
4510
4710
|
bool upb_Array_Insert(upb_Array* arr, size_t i, size_t count,
|
4511
4711
|
upb_Arena* arena) {
|
4712
|
+
UPB_ASSERT(!upb_Array_IsFrozen(arr));
|
4512
4713
|
UPB_ASSERT(arena);
|
4513
4714
|
UPB_ASSERT(i <= arr->UPB_PRIVATE(size));
|
4514
4715
|
UPB_ASSERT(count + arr->UPB_PRIVATE(size) >= count);
|
@@ -4526,6 +4727,7 @@ bool upb_Array_Insert(upb_Array* arr, size_t i, size_t count,
|
|
4526
4727
|
* |------------|XXXXXXXX|--------|
|
4527
4728
|
*/
|
4528
4729
|
void upb_Array_Delete(upb_Array* arr, size_t i, size_t count) {
|
4730
|
+
UPB_ASSERT(!upb_Array_IsFrozen(arr));
|
4529
4731
|
const size_t end = i + count;
|
4530
4732
|
UPB_ASSERT(i <= end);
|
4531
4733
|
UPB_ASSERT(end <= arr->UPB_PRIVATE(size));
|
@@ -4534,6 +4736,7 @@ void upb_Array_Delete(upb_Array* arr, size_t i, size_t count) {
|
|
4534
4736
|
}
|
4535
4737
|
|
4536
4738
|
bool upb_Array_Resize(upb_Array* arr, size_t size, upb_Arena* arena) {
|
4739
|
+
UPB_ASSERT(!upb_Array_IsFrozen(arr));
|
4537
4740
|
const size_t oldsize = arr->UPB_PRIVATE(size);
|
4538
4741
|
if (UPB_UNLIKELY(
|
4539
4742
|
!UPB_PRIVATE(_upb_Array_ResizeUninitialized)(arr, size, arena))) {
|
@@ -4567,6 +4770,20 @@ bool UPB_PRIVATE(_upb_Array_Realloc)(upb_Array* array, size_t min_capacity,
|
|
4567
4770
|
return true;
|
4568
4771
|
}
|
4569
4772
|
|
4773
|
+
void upb_Array_Freeze(upb_Array* arr, const upb_MiniTable* m) {
|
4774
|
+
if (upb_Array_IsFrozen(arr)) return;
|
4775
|
+
UPB_PRIVATE(_upb_Array_ShallowFreeze)(arr);
|
4776
|
+
|
4777
|
+
if (m) {
|
4778
|
+
const size_t size = upb_Array_Size(arr);
|
4779
|
+
|
4780
|
+
for (size_t i = 0; i < size; i++) {
|
4781
|
+
upb_MessageValue val = upb_Array_Get(arr, i);
|
4782
|
+
upb_Message_Freeze((upb_Message*)val.msg_val, m);
|
4783
|
+
}
|
4784
|
+
}
|
4785
|
+
}
|
4786
|
+
|
4570
4787
|
|
4571
4788
|
#include <stddef.h>
|
4572
4789
|
#include <stdint.h>
|
@@ -4583,19 +4800,20 @@ const upb_MiniTableExtension* upb_Message_ExtensionByIndex(
|
|
4583
4800
|
return ext[index].ext;
|
4584
4801
|
}
|
4585
4802
|
|
4586
|
-
const
|
4587
|
-
|
4803
|
+
const upb_MiniTableExtension* upb_Message_FindExtensionByNumber(
|
4804
|
+
const upb_Message* msg, uint32_t field_number) {
|
4588
4805
|
size_t count;
|
4589
4806
|
const upb_Extension* ext = UPB_PRIVATE(_upb_Message_Getexts)(msg, &count);
|
4590
4807
|
|
4591
|
-
|
4592
|
-
|
4593
|
-
|
4808
|
+
for (; count--; ext++) {
|
4809
|
+
const upb_MiniTableExtension* e = ext->ext;
|
4810
|
+
if (upb_MiniTableExtension_Number(e) == field_number) return e;
|
4594
4811
|
}
|
4595
4812
|
return NULL;
|
4596
4813
|
}
|
4597
4814
|
|
4598
4815
|
|
4816
|
+
#include <stdint.h>
|
4599
4817
|
#include <string.h>
|
4600
4818
|
|
4601
4819
|
|
@@ -4694,6 +4912,20 @@ upb_MessageValue upb_MapIterator_Value(const upb_Map* map, size_t iter) {
|
|
4694
4912
|
return ret;
|
4695
4913
|
}
|
4696
4914
|
|
4915
|
+
void upb_Map_Freeze(upb_Map* map, const upb_MiniTable* m) {
|
4916
|
+
if (upb_Map_IsFrozen(map)) return;
|
4917
|
+
UPB_PRIVATE(_upb_Map_ShallowFreeze)(map);
|
4918
|
+
|
4919
|
+
if (m) {
|
4920
|
+
size_t iter = kUpb_Map_Begin;
|
4921
|
+
upb_MessageValue key, val;
|
4922
|
+
|
4923
|
+
while (upb_Map_Next(map, &key, &val, &iter)) {
|
4924
|
+
upb_Message_Freeze((upb_Message*)val.msg_val, m);
|
4925
|
+
}
|
4926
|
+
}
|
4927
|
+
}
|
4928
|
+
|
4697
4929
|
// EVERYTHING BELOW THIS LINE IS INTERNAL - DO NOT USE /////////////////////////
|
4698
4930
|
|
4699
4931
|
upb_Map* _upb_Map_New(upb_Arena* a, size_t key_size, size_t value_size) {
|
@@ -4703,6 +4935,7 @@ upb_Map* _upb_Map_New(upb_Arena* a, size_t key_size, size_t value_size) {
|
|
4703
4935
|
upb_strtable_init(&map->table, 4, a);
|
4704
4936
|
map->key_size = key_size;
|
4705
4937
|
map->val_size = value_size;
|
4938
|
+
map->UPB_PRIVATE(is_frozen) = false;
|
4706
4939
|
|
4707
4940
|
return map;
|
4708
4941
|
}
|
@@ -4866,22 +5099,24 @@ upb_Message* upb_Message_New(const upb_MiniTable* m, upb_Arena* a) {
|
|
4866
5099
|
|
4867
5100
|
bool UPB_PRIVATE(_upb_Message_AddUnknown)(upb_Message* msg, const char* data,
|
4868
5101
|
size_t len, upb_Arena* arena) {
|
5102
|
+
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
4869
5103
|
if (!UPB_PRIVATE(_upb_Message_Realloc)(msg, len, arena)) return false;
|
4870
|
-
upb_Message_Internal* in = msg
|
5104
|
+
upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
|
4871
5105
|
memcpy(UPB_PTR_AT(in, in->unknown_end, char), data, len);
|
4872
5106
|
in->unknown_end += len;
|
4873
5107
|
return true;
|
4874
5108
|
}
|
4875
5109
|
|
4876
5110
|
void _upb_Message_DiscardUnknown_shallow(upb_Message* msg) {
|
4877
|
-
|
5111
|
+
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
5112
|
+
upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
|
4878
5113
|
if (in) {
|
4879
5114
|
in->unknown_end = message_overhead;
|
4880
5115
|
}
|
4881
5116
|
}
|
4882
5117
|
|
4883
5118
|
const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len) {
|
4884
|
-
upb_Message_Internal* in = msg
|
5119
|
+
upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
|
4885
5120
|
if (in) {
|
4886
5121
|
*len = in->unknown_end - message_overhead;
|
4887
5122
|
return (char*)(in + 1);
|
@@ -4892,7 +5127,8 @@ const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len) {
|
|
4892
5127
|
}
|
4893
5128
|
|
4894
5129
|
void upb_Message_DeleteUnknown(upb_Message* msg, const char* data, size_t len) {
|
4895
|
-
|
5130
|
+
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
5131
|
+
upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
|
4896
5132
|
const char* internal_unknown_end = UPB_PTR_AT(in, in->unknown_end, char);
|
4897
5133
|
|
4898
5134
|
#ifndef NDEBUG
|
@@ -4916,35 +5152,296 @@ size_t upb_Message_ExtensionCount(const upb_Message* msg) {
|
|
4916
5152
|
return count;
|
4917
5153
|
}
|
4918
5154
|
|
5155
|
+
void upb_Message_Freeze(upb_Message* msg, const upb_MiniTable* m) {
|
5156
|
+
if (upb_Message_IsFrozen(msg)) return;
|
5157
|
+
UPB_PRIVATE(_upb_Message_ShallowFreeze)(msg);
|
5158
|
+
|
5159
|
+
// Base Fields.
|
5160
|
+
const size_t field_count = upb_MiniTable_FieldCount(m);
|
5161
|
+
|
5162
|
+
for (size_t i = 0; i < field_count; i++) {
|
5163
|
+
const upb_MiniTableField* f = upb_MiniTable_GetFieldByIndex(m, i);
|
5164
|
+
const upb_MiniTable* m2 = upb_MiniTable_SubMessage(m, f);
|
5165
|
+
|
5166
|
+
switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(f)) {
|
5167
|
+
case kUpb_FieldMode_Array: {
|
5168
|
+
upb_Array* arr = upb_Message_GetMutableArray(msg, f);
|
5169
|
+
if (arr) upb_Array_Freeze(arr, m2);
|
5170
|
+
break;
|
5171
|
+
}
|
5172
|
+
case kUpb_FieldMode_Map: {
|
5173
|
+
upb_Map* map = upb_Message_GetMutableMap(msg, f);
|
5174
|
+
if (map) {
|
5175
|
+
const upb_MiniTableField* f2 = upb_MiniTable_MapValue(m2);
|
5176
|
+
const upb_MiniTable* m3 = upb_MiniTable_SubMessage(m2, f2);
|
5177
|
+
upb_Map_Freeze(map, m3);
|
5178
|
+
}
|
5179
|
+
break;
|
5180
|
+
}
|
5181
|
+
case kUpb_FieldMode_Scalar: {
|
5182
|
+
if (m2) {
|
5183
|
+
upb_Message* msg2 = upb_Message_GetMutableMessage(msg, f);
|
5184
|
+
if (msg2) upb_Message_Freeze(msg2, m2);
|
5185
|
+
}
|
5186
|
+
break;
|
5187
|
+
}
|
5188
|
+
}
|
5189
|
+
}
|
5190
|
+
|
5191
|
+
// Extensions.
|
5192
|
+
size_t ext_count;
|
5193
|
+
const upb_Extension* ext = UPB_PRIVATE(_upb_Message_Getexts)(msg, &ext_count);
|
5194
|
+
|
5195
|
+
for (size_t i = 0; i < ext_count; i++) {
|
5196
|
+
const upb_MiniTableExtension* e = ext[i].ext;
|
5197
|
+
const upb_MiniTableField* f = &e->UPB_PRIVATE(field);
|
5198
|
+
const upb_MiniTable* m2 = upb_MiniTableExtension_GetSubMessage(e);
|
5199
|
+
|
5200
|
+
upb_MessageValue val;
|
5201
|
+
memcpy(&val, &ext[i].data, sizeof(upb_MessageValue));
|
5202
|
+
|
5203
|
+
switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(f)) {
|
5204
|
+
case kUpb_FieldMode_Array: {
|
5205
|
+
upb_Array* arr = (upb_Array*)val.array_val;
|
5206
|
+
if (arr) upb_Array_Freeze(arr, m2);
|
5207
|
+
break;
|
5208
|
+
}
|
5209
|
+
case kUpb_FieldMode_Map:
|
5210
|
+
UPB_UNREACHABLE(); // Maps cannot be extensions.
|
5211
|
+
break;
|
5212
|
+
case kUpb_FieldMode_Scalar:
|
5213
|
+
if (upb_MiniTableField_IsSubMessage(f)) {
|
5214
|
+
upb_Message* msg2 = (upb_Message*)val.msg_val;
|
5215
|
+
if (msg2) upb_Message_Freeze(msg2, m2);
|
5216
|
+
}
|
5217
|
+
break;
|
5218
|
+
}
|
5219
|
+
}
|
5220
|
+
}
|
4919
5221
|
|
4920
|
-
|
5222
|
+
|
5223
|
+
#include <stddef.h>
|
4921
5224
|
|
4922
5225
|
|
4923
5226
|
// Must be last.
|
4924
5227
|
|
4925
|
-
|
4926
|
-
|
4927
|
-
|
4928
|
-
|
5228
|
+
#define kUpb_BaseField_Begin ((size_t)-1)
|
5229
|
+
#define kUpb_Extension_Begin ((size_t)-1)
|
5230
|
+
|
5231
|
+
#ifdef __cplusplus
|
5232
|
+
extern "C" {
|
5233
|
+
#endif
|
5234
|
+
|
5235
|
+
static bool _upb_Message_NextBaseField(const upb_Message* msg,
|
5236
|
+
const upb_MiniTable* m,
|
5237
|
+
const upb_MiniTableField** out_f,
|
5238
|
+
upb_MessageValue* out_v, size_t* iter) {
|
5239
|
+
const size_t count = upb_MiniTable_FieldCount(m);
|
5240
|
+
size_t i = *iter;
|
5241
|
+
|
5242
|
+
while (++i < count) {
|
5243
|
+
const upb_MiniTableField* f = upb_MiniTable_GetFieldByIndex(m, i);
|
5244
|
+
const void* src = UPB_PRIVATE(_upb_Message_DataPtr)(msg, f);
|
5245
|
+
|
5246
|
+
upb_MessageValue val;
|
5247
|
+
UPB_PRIVATE(_upb_MiniTableField_DataCopy)(f, &val, src);
|
5248
|
+
|
5249
|
+
// Skip field if unset or empty.
|
5250
|
+
if (upb_MiniTableField_HasPresence(f)) {
|
5251
|
+
if (!upb_Message_HasBaseField(msg, f)) continue;
|
5252
|
+
} else {
|
5253
|
+
if (UPB_PRIVATE(_upb_MiniTableField_DataIsZero)(f, src)) continue;
|
5254
|
+
|
5255
|
+
if (upb_MiniTableField_IsArray(f)) {
|
5256
|
+
if (upb_Array_Size(val.array_val) == 0) continue;
|
5257
|
+
} else if (upb_MiniTableField_IsMap(f)) {
|
5258
|
+
if (upb_Map_Size(val.map_val) == 0) continue;
|
5259
|
+
}
|
5260
|
+
}
|
5261
|
+
|
5262
|
+
*out_f = f;
|
5263
|
+
*out_v = val;
|
5264
|
+
*iter = i;
|
5265
|
+
return true;
|
5266
|
+
}
|
5267
|
+
|
5268
|
+
return false;
|
5269
|
+
}
|
4929
5270
|
|
4930
|
-
|
4931
|
-
|
5271
|
+
static bool _upb_Message_NextExtension(const upb_Message* msg,
|
5272
|
+
const upb_MiniTable* m,
|
5273
|
+
const upb_MiniTableExtension** out_e,
|
5274
|
+
upb_MessageValue* out_v, size_t* iter) {
|
5275
|
+
size_t count;
|
5276
|
+
const upb_Extension* exts = UPB_PRIVATE(_upb_Message_Getexts)(msg, &count);
|
5277
|
+
size_t i = *iter;
|
4932
5278
|
|
4933
|
-
|
4934
|
-
|
4935
|
-
|
4936
|
-
|
4937
|
-
|
5279
|
+
if (++i < count) {
|
5280
|
+
*out_e = exts[i].ext;
|
5281
|
+
*out_v = exts[i].data;
|
5282
|
+
*iter = i;
|
5283
|
+
return true;
|
5284
|
+
}
|
5285
|
+
|
5286
|
+
return false;
|
5287
|
+
}
|
5288
|
+
|
5289
|
+
bool upb_Message_IsEmpty(const upb_Message* msg, const upb_MiniTable* m) {
|
5290
|
+
if (upb_Message_ExtensionCount(msg)) return false;
|
4938
5291
|
|
4939
|
-
|
4940
|
-
|
4941
|
-
|
5292
|
+
const upb_MiniTableField* f;
|
5293
|
+
upb_MessageValue v;
|
5294
|
+
size_t iter = kUpb_BaseField_Begin;
|
5295
|
+
return !_upb_Message_NextBaseField(msg, m, &f, &v, &iter);
|
5296
|
+
}
|
5297
|
+
|
5298
|
+
static bool _upb_Array_IsEqual(const upb_Array* arr1, const upb_Array* arr2,
|
5299
|
+
upb_CType ctype, const upb_MiniTable* m,
|
5300
|
+
int options) {
|
5301
|
+
// Check for trivial equality.
|
5302
|
+
if (arr1 == arr2) return true;
|
5303
|
+
|
5304
|
+
// Must have identical element counts.
|
5305
|
+
const size_t size1 = arr1 ? upb_Array_Size(arr1) : 0;
|
5306
|
+
const size_t size2 = arr2 ? upb_Array_Size(arr2) : 0;
|
5307
|
+
if (size1 != size2) return false;
|
5308
|
+
|
5309
|
+
for (size_t i = 0; i < size1; i++) {
|
5310
|
+
const upb_MessageValue val1 = upb_Array_Get(arr1, i);
|
5311
|
+
const upb_MessageValue val2 = upb_Array_Get(arr2, i);
|
5312
|
+
|
5313
|
+
if (!upb_MessageValue_IsEqual(val1, val2, ctype, m, options)) return false;
|
5314
|
+
}
|
5315
|
+
|
5316
|
+
return true;
|
5317
|
+
}
|
5318
|
+
|
5319
|
+
static bool _upb_Map_IsEqual(const upb_Map* map1, const upb_Map* map2,
|
5320
|
+
const upb_MiniTable* m, int options) {
|
5321
|
+
// Check for trivial equality.
|
5322
|
+
if (map1 == map2) return true;
|
5323
|
+
|
5324
|
+
// Must have identical element counts.
|
5325
|
+
size_t size1 = map1 ? upb_Map_Size(map1) : 0;
|
5326
|
+
size_t size2 = map2 ? upb_Map_Size(map2) : 0;
|
5327
|
+
if (size1 != size2) return false;
|
5328
|
+
|
5329
|
+
const upb_MiniTableField* f = upb_MiniTable_MapValue(m);
|
5330
|
+
const upb_MiniTable* m2_value = upb_MiniTable_SubMessage(m, f);
|
5331
|
+
const upb_CType ctype = upb_MiniTableField_CType(f);
|
5332
|
+
|
5333
|
+
upb_MessageValue key, val1, val2;
|
5334
|
+
size_t iter = kUpb_Map_Begin;
|
5335
|
+
while (upb_Map_Next(map1, &key, &val1, &iter)) {
|
5336
|
+
if (!upb_Map_Get(map2, key, &val2)) return false;
|
5337
|
+
if (!upb_MessageValue_IsEqual(val1, val2, ctype, m2_value, options))
|
5338
|
+
return false;
|
5339
|
+
}
|
5340
|
+
|
5341
|
+
return true;
|
5342
|
+
}
|
5343
|
+
|
5344
|
+
static bool _upb_Message_BaseFieldsAreEqual(const upb_Message* msg1,
|
5345
|
+
const upb_Message* msg2,
|
5346
|
+
const upb_MiniTable* m,
|
5347
|
+
int options) {
|
5348
|
+
// Iterate over all base fields for each message.
|
5349
|
+
// The order will always match if the messages are equal.
|
5350
|
+
size_t iter1 = kUpb_BaseField_Begin;
|
5351
|
+
size_t iter2 = kUpb_BaseField_Begin;
|
5352
|
+
|
5353
|
+
for (;;) {
|
5354
|
+
const upb_MiniTableField *f1, *f2;
|
5355
|
+
upb_MessageValue val1, val2;
|
5356
|
+
|
5357
|
+
const bool got1 = _upb_Message_NextBaseField(msg1, m, &f1, &val1, &iter1);
|
5358
|
+
const bool got2 = _upb_Message_NextBaseField(msg2, m, &f2, &val2, &iter2);
|
5359
|
+
|
5360
|
+
if (got1 != got2) return false; // Must have identical field counts.
|
5361
|
+
if (!got1) return true; // Loop termination condition.
|
5362
|
+
if (f1 != f2) return false; // Must have identical fields set.
|
5363
|
+
|
5364
|
+
const upb_MiniTable* subm = upb_MiniTable_SubMessage(m, f1);
|
5365
|
+
const upb_CType ctype = upb_MiniTableField_CType(f1);
|
5366
|
+
|
5367
|
+
bool eq;
|
5368
|
+
switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(f1)) {
|
5369
|
+
case kUpb_FieldMode_Array:
|
5370
|
+
eq = _upb_Array_IsEqual(val1.array_val, val2.array_val, ctype, subm,
|
5371
|
+
options);
|
5372
|
+
break;
|
5373
|
+
case kUpb_FieldMode_Map:
|
5374
|
+
eq = _upb_Map_IsEqual(val1.map_val, val2.map_val, subm, options);
|
5375
|
+
break;
|
5376
|
+
case kUpb_FieldMode_Scalar:
|
5377
|
+
eq = upb_MessageValue_IsEqual(val1, val2, ctype, subm, options);
|
5378
|
+
break;
|
5379
|
+
}
|
5380
|
+
if (!eq) return false;
|
5381
|
+
}
|
5382
|
+
}
|
5383
|
+
|
5384
|
+
static bool _upb_Message_ExtensionsAreEqual(const upb_Message* msg1,
|
5385
|
+
const upb_Message* msg2,
|
5386
|
+
const upb_MiniTable* m,
|
5387
|
+
int options) {
|
5388
|
+
// Must have identical extension counts.
|
5389
|
+
if (upb_Message_ExtensionCount(msg1) != upb_Message_ExtensionCount(msg2)) {
|
4942
5390
|
return false;
|
4943
5391
|
}
|
4944
5392
|
|
4945
|
-
const
|
4946
|
-
|
4947
|
-
|
5393
|
+
const upb_MiniTableExtension* e;
|
5394
|
+
upb_MessageValue val1;
|
5395
|
+
|
5396
|
+
// Iterate over all extensions for msg1, and search msg2 for each extension.
|
5397
|
+
size_t iter1 = kUpb_Extension_Begin;
|
5398
|
+
while (_upb_Message_NextExtension(msg1, m, &e, &val1, &iter1)) {
|
5399
|
+
const upb_Extension* ext2 = UPB_PRIVATE(_upb_Message_Getext)(msg2, e);
|
5400
|
+
if (!ext2) return false;
|
5401
|
+
|
5402
|
+
const upb_MessageValue val2 = ext2->data;
|
5403
|
+
const upb_MiniTableField* f = &e->UPB_PRIVATE(field);
|
5404
|
+
const upb_MiniTable* subm = upb_MiniTableField_IsSubMessage(f)
|
5405
|
+
? upb_MiniTableExtension_GetSubMessage(e)
|
5406
|
+
: NULL;
|
5407
|
+
const upb_CType ctype = upb_MiniTableField_CType(f);
|
5408
|
+
|
5409
|
+
bool eq;
|
5410
|
+
switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(f)) {
|
5411
|
+
case kUpb_FieldMode_Array:
|
5412
|
+
eq = _upb_Array_IsEqual(val1.array_val, val2.array_val, ctype, subm,
|
5413
|
+
options);
|
5414
|
+
break;
|
5415
|
+
case kUpb_FieldMode_Map:
|
5416
|
+
UPB_UNREACHABLE(); // Maps cannot be extensions.
|
5417
|
+
break;
|
5418
|
+
case kUpb_FieldMode_Scalar: {
|
5419
|
+
eq = upb_MessageValue_IsEqual(val1, val2, ctype, subm, options);
|
5420
|
+
break;
|
5421
|
+
}
|
5422
|
+
}
|
5423
|
+
if (!eq) return false;
|
5424
|
+
}
|
5425
|
+
return true;
|
5426
|
+
}
|
5427
|
+
|
5428
|
+
bool upb_Message_IsEqual(const upb_Message* msg1, const upb_Message* msg2,
|
5429
|
+
const upb_MiniTable* m, int options) {
|
5430
|
+
if (UPB_UNLIKELY(msg1 == msg2)) return true;
|
5431
|
+
|
5432
|
+
if (!_upb_Message_BaseFieldsAreEqual(msg1, msg2, m, options)) return false;
|
5433
|
+
if (!_upb_Message_ExtensionsAreEqual(msg1, msg2, m, options)) return false;
|
5434
|
+
|
5435
|
+
if (!(options & kUpb_CompareOption_IncludeUnknownFields)) return true;
|
5436
|
+
|
5437
|
+
// Check the unknown fields.
|
5438
|
+
size_t usize1, usize2;
|
5439
|
+
const char* uf1 = upb_Message_GetUnknown(msg1, &usize1);
|
5440
|
+
const char* uf2 = upb_Message_GetUnknown(msg2, &usize2);
|
5441
|
+
|
5442
|
+
// The wire encoder enforces a maximum depth of 100 so we match that here.
|
5443
|
+
return UPB_PRIVATE(_upb_Message_UnknownFieldsAreEqual)(
|
5444
|
+
uf1, usize1, uf2, usize2, 100) == kUpb_UnknownCompareResult_Equal;
|
4948
5445
|
}
|
4949
5446
|
|
4950
5447
|
|
@@ -5018,7 +5515,7 @@ upb_Map* upb_Map_DeepClone(const upb_Map* map, upb_CType key_type,
|
|
5018
5515
|
size_t iter = kUpb_Map_Begin;
|
5019
5516
|
while (upb_Map_Next(map, &key, &val, &iter)) {
|
5020
5517
|
const upb_MiniTableField* value_field =
|
5021
|
-
|
5518
|
+
upb_MiniTable_MapValue(map_entry_table);
|
5022
5519
|
const upb_MiniTable* value_sub =
|
5023
5520
|
upb_MiniTableField_CType(value_field) == kUpb_CType_Message
|
5024
5521
|
? upb_MiniTable_GetSubMessageTable(map_entry_table, value_field)
|
@@ -5044,10 +5541,9 @@ static upb_Map* upb_Message_Map_DeepClone(const upb_Map* map,
|
|
5044
5541
|
mini_table->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
|
5045
5542
|
UPB_ASSERT(map_entry_table);
|
5046
5543
|
|
5047
|
-
const upb_MiniTableField* key_field =
|
5048
|
-
&map_entry_table->UPB_PRIVATE(fields)[0];
|
5544
|
+
const upb_MiniTableField* key_field = upb_MiniTable_MapKey(map_entry_table);
|
5049
5545
|
const upb_MiniTableField* value_field =
|
5050
|
-
|
5546
|
+
upb_MiniTable_MapValue(map_entry_table);
|
5051
5547
|
|
5052
5548
|
upb_Map* cloned_map = upb_Map_DeepClone(
|
5053
5549
|
map, upb_MiniTableField_CType(key_field),
|
@@ -5055,13 +5551,13 @@ static upb_Map* upb_Message_Map_DeepClone(const upb_Map* map,
|
|
5055
5551
|
if (!cloned_map) {
|
5056
5552
|
return NULL;
|
5057
5553
|
}
|
5058
|
-
|
5554
|
+
upb_Message_SetBaseField(clone, f, &cloned_map);
|
5059
5555
|
return cloned_map;
|
5060
5556
|
}
|
5061
5557
|
|
5062
5558
|
upb_Array* upb_Array_DeepClone(const upb_Array* array, upb_CType value_type,
|
5063
5559
|
const upb_MiniTable* sub, upb_Arena* arena) {
|
5064
|
-
const size_t size = array
|
5560
|
+
const size_t size = upb_Array_Size(array);
|
5065
5561
|
const int lg2 = UPB_PRIVATE(_upb_CType_SizeLg2)(value_type);
|
5066
5562
|
upb_Array* cloned_array = UPB_PRIVATE(_upb_Array_New)(arena, size, lg2);
|
5067
5563
|
if (!cloned_array) {
|
@@ -5093,7 +5589,7 @@ static bool upb_Message_Array_DeepClone(const upb_Array* array,
|
|
5093
5589
|
arena);
|
5094
5590
|
|
5095
5591
|
// Clear out upb_Array* due to parent memcpy.
|
5096
|
-
|
5592
|
+
upb_Message_SetBaseField(clone, field, &cloned_array);
|
5097
5593
|
return true;
|
5098
5594
|
}
|
5099
5595
|
|
@@ -5102,8 +5598,7 @@ static bool upb_Clone_ExtensionValue(
|
|
5102
5598
|
upb_Extension* dest, upb_Arena* arena) {
|
5103
5599
|
dest->data = source->data;
|
5104
5600
|
return upb_Clone_MessageValue(
|
5105
|
-
&dest->data,
|
5106
|
-
upb_MiniTableField_CType(&mini_table_ext->UPB_PRIVATE(field)),
|
5601
|
+
&dest->data, upb_MiniTableExtension_CType(mini_table_ext),
|
5107
5602
|
upb_MiniTableExtension_GetSubMessage(mini_table_ext), arena);
|
5108
5603
|
}
|
5109
5604
|
|
@@ -5113,8 +5608,9 @@ upb_Message* _upb_Message_Copy(upb_Message* dst, const upb_Message* src,
|
|
5113
5608
|
upb_StringView empty_string = upb_StringView_FromDataAndSize(NULL, 0);
|
5114
5609
|
// Only copy message area skipping upb_Message_Internal.
|
5115
5610
|
memcpy(dst + 1, src + 1, mini_table->UPB_PRIVATE(size) - sizeof(upb_Message));
|
5116
|
-
for (
|
5117
|
-
const upb_MiniTableField* field =
|
5611
|
+
for (int i = 0; i < upb_MiniTable_FieldCount(mini_table); ++i) {
|
5612
|
+
const upb_MiniTableField* field =
|
5613
|
+
upb_MiniTable_GetFieldByIndex(mini_table, i);
|
5118
5614
|
if (upb_MiniTableField_IsScalar(field)) {
|
5119
5615
|
switch (upb_MiniTableField_CType(field)) {
|
5120
5616
|
case kUpb_CType_Message: {
|
@@ -5188,7 +5684,7 @@ upb_Message* _upb_Message_Copy(upb_Message* dst, const upb_Message* src,
|
|
5188
5684
|
return NULL;
|
5189
5685
|
}
|
5190
5686
|
} else {
|
5191
|
-
upb_Array* msg_array = (upb_Array*)msg_ext->data.
|
5687
|
+
upb_Array* msg_array = (upb_Array*)msg_ext->data.array_val;
|
5192
5688
|
UPB_ASSERT(msg_array);
|
5193
5689
|
upb_Array* cloned_array = upb_Array_DeepClone(
|
5194
5690
|
msg_array, upb_MiniTableField_CType(field),
|
@@ -5196,7 +5692,7 @@ upb_Message* _upb_Message_Copy(upb_Message* dst, const upb_Message* src,
|
|
5196
5692
|
if (!cloned_array) {
|
5197
5693
|
return NULL;
|
5198
5694
|
}
|
5199
|
-
dst_ext->data.
|
5695
|
+
dst_ext->data.array_val = cloned_array;
|
5200
5696
|
}
|
5201
5697
|
}
|
5202
5698
|
|
@@ -5348,9 +5844,9 @@ static upb_MiniTableEnum* upb_MtDecoder_BuildMiniTableEnum(
|
|
5348
5844
|
return upb_MtDecoder_DoBuildMiniTableEnum(decoder, data, len);
|
5349
5845
|
}
|
5350
5846
|
|
5351
|
-
upb_MiniTableEnum*
|
5352
|
-
|
5353
|
-
|
5847
|
+
upb_MiniTableEnum* upb_MiniTableEnum_Build(const char* data, size_t len,
|
5848
|
+
upb_Arena* arena,
|
5849
|
+
upb_Status* status) {
|
5354
5850
|
upb_MdEnumDecoder decoder = {
|
5355
5851
|
.base =
|
5356
5852
|
{
|
@@ -5391,7 +5887,7 @@ typedef enum {
|
|
5391
5887
|
kUpb_LayoutItemType_Max = kUpb_LayoutItemType_Field,
|
5392
5888
|
} upb_LayoutItemType;
|
5393
5889
|
|
5394
|
-
#define kUpb_LayoutItem_IndexSentinel ((uint16_t)-1)
|
5890
|
+
#define kUpb_LayoutItem_IndexSentinel ((uint16_t) - 1)
|
5395
5891
|
|
5396
5892
|
typedef struct {
|
5397
5893
|
// Index of the corresponding field. When this is a oneof field, the field's
|
@@ -5588,6 +6084,12 @@ static void upb_MtDecoder_ModifyField(upb_MtDecoder* d,
|
|
5588
6084
|
upb_MiniTableField_Number(field));
|
5589
6085
|
}
|
5590
6086
|
|
6087
|
+
if (singular && upb_MiniTableField_IsSubMessage(field)) {
|
6088
|
+
upb_MdDecoder_ErrorJmp(&d->base,
|
6089
|
+
"Field %" PRIu32 " cannot be a singular submessage",
|
6090
|
+
upb_MiniTableField_Number(field));
|
6091
|
+
}
|
6092
|
+
|
5591
6093
|
if (singular) field->UPB_PRIVATE(offset) = kNoPresence;
|
5592
6094
|
if (required) {
|
5593
6095
|
field->UPB_PRIVATE(offset) = kRequiredPresence;
|
@@ -6074,6 +6576,11 @@ static upb_MiniTable* upb_MtDecoder_DoBuildMiniTableWithBuf(
|
|
6074
6576
|
decoder->table->UPB_PRIVATE(dense_below) = 0;
|
6075
6577
|
decoder->table->UPB_PRIVATE(table_mask) = -1;
|
6076
6578
|
decoder->table->UPB_PRIVATE(required_count) = 0;
|
6579
|
+
#if UPB_TRACING_ENABLED
|
6580
|
+
// MiniTables built from MiniDescriptors will not be able to vend the message
|
6581
|
+
// name unless it is explicitly set with upb_MiniTable_SetFullName().
|
6582
|
+
decoder->table->UPB_PRIVATE(full_name) = 0;
|
6583
|
+
#endif
|
6077
6584
|
|
6078
6585
|
// Strip off and verify the version tag.
|
6079
6586
|
if (!len--) goto done;
|
@@ -6292,13 +6799,13 @@ bool upb_MiniTable_SetSubEnum(upb_MiniTable* table, upb_MiniTableField* field,
|
|
6292
6799
|
return true;
|
6293
6800
|
}
|
6294
6801
|
|
6295
|
-
uint32_t upb_MiniTable_GetSubList(const upb_MiniTable*
|
6802
|
+
uint32_t upb_MiniTable_GetSubList(const upb_MiniTable* m,
|
6296
6803
|
const upb_MiniTableField** subs) {
|
6297
6804
|
uint32_t msg_count = 0;
|
6298
6805
|
uint32_t enum_count = 0;
|
6299
6806
|
|
6300
|
-
for (int i = 0; i <
|
6301
|
-
const upb_MiniTableField* f =
|
6807
|
+
for (int i = 0; i < upb_MiniTable_FieldCount(m); i++) {
|
6808
|
+
const upb_MiniTableField* f = upb_MiniTable_GetFieldByIndex(m, i);
|
6302
6809
|
if (upb_MiniTableField_CType(f) == kUpb_CType_Message) {
|
6303
6810
|
*subs = f;
|
6304
6811
|
++subs;
|
@@ -6306,9 +6813,9 @@ uint32_t upb_MiniTable_GetSubList(const upb_MiniTable* mt,
|
|
6306
6813
|
}
|
6307
6814
|
}
|
6308
6815
|
|
6309
|
-
for (int i = 0; i <
|
6310
|
-
const upb_MiniTableField* f =
|
6311
|
-
if (
|
6816
|
+
for (int i = 0; i < upb_MiniTable_FieldCount(m); i++) {
|
6817
|
+
const upb_MiniTableField* f = upb_MiniTable_GetFieldByIndex(m, i);
|
6818
|
+
if (upb_MiniTableField_IsClosedEnum(f)) {
|
6312
6819
|
*subs = f;
|
6313
6820
|
++subs;
|
6314
6821
|
enum_count++;
|
@@ -6321,36 +6828,34 @@ uint32_t upb_MiniTable_GetSubList(const upb_MiniTable* mt,
|
|
6321
6828
|
// The list of sub_tables and sub_enums must exactly match the number and order
|
6322
6829
|
// of sub-message fields and sub-enum fields given by upb_MiniTable_GetSubList()
|
6323
6830
|
// above.
|
6324
|
-
bool upb_MiniTable_Link(upb_MiniTable*
|
6831
|
+
bool upb_MiniTable_Link(upb_MiniTable* m, const upb_MiniTable** sub_tables,
|
6325
6832
|
size_t sub_table_count,
|
6326
6833
|
const upb_MiniTableEnum** sub_enums,
|
6327
6834
|
size_t sub_enum_count) {
|
6328
6835
|
uint32_t msg_count = 0;
|
6329
6836
|
uint32_t enum_count = 0;
|
6330
6837
|
|
6331
|
-
for (int i = 0; i <
|
6332
|
-
upb_MiniTableField* f =
|
6838
|
+
for (int i = 0; i < upb_MiniTable_FieldCount(m); i++) {
|
6839
|
+
upb_MiniTableField* f =
|
6840
|
+
(upb_MiniTableField*)upb_MiniTable_GetFieldByIndex(m, i);
|
6333
6841
|
if (upb_MiniTableField_CType(f) == kUpb_CType_Message) {
|
6334
6842
|
const upb_MiniTable* sub = sub_tables[msg_count++];
|
6335
6843
|
if (msg_count > sub_table_count) return false;
|
6336
|
-
if (sub
|
6337
|
-
if (!upb_MiniTable_SetSubMessage(mt, f, sub)) return false;
|
6338
|
-
}
|
6844
|
+
if (sub && !upb_MiniTable_SetSubMessage(m, f, sub)) return false;
|
6339
6845
|
}
|
6340
6846
|
}
|
6341
6847
|
|
6342
|
-
for (int i = 0; i <
|
6343
|
-
upb_MiniTableField* f =
|
6848
|
+
for (int i = 0; i < upb_MiniTable_FieldCount(m); i++) {
|
6849
|
+
upb_MiniTableField* f =
|
6850
|
+
(upb_MiniTableField*)upb_MiniTable_GetFieldByIndex(m, i);
|
6344
6851
|
if (upb_MiniTableField_IsClosedEnum(f)) {
|
6345
6852
|
const upb_MiniTableEnum* sub = sub_enums[enum_count++];
|
6346
6853
|
if (enum_count > sub_enum_count) return false;
|
6347
|
-
if (sub
|
6348
|
-
if (!upb_MiniTable_SetSubEnum(mt, f, sub)) return false;
|
6349
|
-
}
|
6854
|
+
if (sub && !upb_MiniTable_SetSubEnum(m, f, sub)) return false;
|
6350
6855
|
}
|
6351
6856
|
}
|
6352
6857
|
|
6353
|
-
return
|
6858
|
+
return (msg_count == sub_table_count) && (enum_count == sub_enum_count);
|
6354
6859
|
}
|
6355
6860
|
|
6356
6861
|
|
@@ -6705,8 +7210,7 @@ static _upb_DecodeLongVarintReturn _upb_Decoder_DecodeLongVarint(
|
|
6705
7210
|
const char* ptr, uint64_t val) {
|
6706
7211
|
_upb_DecodeLongVarintReturn ret = {NULL, 0};
|
6707
7212
|
uint64_t byte;
|
6708
|
-
int i;
|
6709
|
-
for (i = 1; i < 10; i++) {
|
7213
|
+
for (int i = 1; i < 10; i++) {
|
6710
7214
|
byte = (uint8_t)ptr[i];
|
6711
7215
|
val += (byte - 1) << (i * 7);
|
6712
7216
|
if (!(byte & 0x80)) {
|
@@ -6719,8 +7223,8 @@ static _upb_DecodeLongVarintReturn _upb_Decoder_DecodeLongVarint(
|
|
6719
7223
|
}
|
6720
7224
|
|
6721
7225
|
UPB_FORCEINLINE
|
6722
|
-
|
6723
|
-
|
7226
|
+
const char* _upb_Decoder_DecodeVarint(upb_Decoder* d, const char* ptr,
|
7227
|
+
uint64_t* val) {
|
6724
7228
|
uint64_t byte = (uint8_t)*ptr;
|
6725
7229
|
if (UPB_LIKELY((byte & 0x80) == 0)) {
|
6726
7230
|
*val = byte;
|
@@ -6734,8 +7238,8 @@ static const char* _upb_Decoder_DecodeVarint(upb_Decoder* d, const char* ptr,
|
|
6734
7238
|
}
|
6735
7239
|
|
6736
7240
|
UPB_FORCEINLINE
|
6737
|
-
|
6738
|
-
|
7241
|
+
const char* _upb_Decoder_DecodeTag(upb_Decoder* d, const char* ptr,
|
7242
|
+
uint32_t* val) {
|
6739
7243
|
uint64_t byte = (uint8_t)*ptr;
|
6740
7244
|
if (UPB_LIKELY((byte & 0x80) == 0)) {
|
6741
7245
|
*val = byte;
|
@@ -6752,8 +7256,8 @@ static const char* _upb_Decoder_DecodeTag(upb_Decoder* d, const char* ptr,
|
|
6752
7256
|
}
|
6753
7257
|
|
6754
7258
|
UPB_FORCEINLINE
|
6755
|
-
|
6756
|
-
|
7259
|
+
const char* upb_Decoder_DecodeSize(upb_Decoder* d, const char* ptr,
|
7260
|
+
uint32_t* size) {
|
6757
7261
|
uint64_t size64;
|
6758
7262
|
ptr = _upb_Decoder_DecodeVarint(d, ptr, &size64);
|
6759
7263
|
if (size64 >= INT32_MAX ||
|
@@ -6855,11 +7359,10 @@ static const char* _upb_Decoder_ReadString(upb_Decoder* d, const char* ptr,
|
|
6855
7359
|
}
|
6856
7360
|
|
6857
7361
|
UPB_FORCEINLINE
|
6858
|
-
|
6859
|
-
|
6860
|
-
|
6861
|
-
|
6862
|
-
uint32_t expected_end_group) {
|
7362
|
+
const char* _upb_Decoder_RecurseSubMessage(upb_Decoder* d, const char* ptr,
|
7363
|
+
upb_Message* submsg,
|
7364
|
+
const upb_MiniTable* subl,
|
7365
|
+
uint32_t expected_end_group) {
|
6863
7366
|
if (--d->depth < 0) {
|
6864
7367
|
_upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_MaxDepthExceeded);
|
6865
7368
|
}
|
@@ -6872,9 +7375,11 @@ static const char* _upb_Decoder_RecurseSubMessage(upb_Decoder* d,
|
|
6872
7375
|
}
|
6873
7376
|
|
6874
7377
|
UPB_FORCEINLINE
|
6875
|
-
|
6876
|
-
|
6877
|
-
|
7378
|
+
const char* _upb_Decoder_DecodeSubMessage(upb_Decoder* d, const char* ptr,
|
7379
|
+
upb_Message* submsg,
|
7380
|
+
const upb_MiniTableSub* subs,
|
7381
|
+
const upb_MiniTableField* field,
|
7382
|
+
int size) {
|
6878
7383
|
int saved_delta = upb_EpsCopyInputStream_PushLimit(&d->input, ptr, size);
|
6879
7384
|
const upb_MiniTable* subl = _upb_MiniTableSubs_MessageByField(subs, field);
|
6880
7385
|
UPB_ASSERT(subl);
|
@@ -6884,10 +7389,10 @@ static const char* _upb_Decoder_DecodeSubMessage(
|
|
6884
7389
|
}
|
6885
7390
|
|
6886
7391
|
UPB_FORCEINLINE
|
6887
|
-
|
6888
|
-
|
6889
|
-
|
6890
|
-
|
7392
|
+
const char* _upb_Decoder_DecodeGroup(upb_Decoder* d, const char* ptr,
|
7393
|
+
upb_Message* submsg,
|
7394
|
+
const upb_MiniTable* subl,
|
7395
|
+
uint32_t number) {
|
6891
7396
|
if (_upb_Decoder_IsDone(d, &ptr)) {
|
6892
7397
|
_upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_Malformed);
|
6893
7398
|
}
|
@@ -6897,16 +7402,16 @@ static const char* _upb_Decoder_DecodeGroup(upb_Decoder* d, const char* ptr,
|
|
6897
7402
|
}
|
6898
7403
|
|
6899
7404
|
UPB_FORCEINLINE
|
6900
|
-
|
6901
|
-
|
6902
|
-
uint32_t number) {
|
7405
|
+
const char* _upb_Decoder_DecodeUnknownGroup(upb_Decoder* d, const char* ptr,
|
7406
|
+
uint32_t number) {
|
6903
7407
|
return _upb_Decoder_DecodeGroup(d, ptr, NULL, NULL, number);
|
6904
7408
|
}
|
6905
7409
|
|
6906
7410
|
UPB_FORCEINLINE
|
6907
|
-
|
6908
|
-
|
6909
|
-
|
7411
|
+
const char* _upb_Decoder_DecodeKnownGroup(upb_Decoder* d, const char* ptr,
|
7412
|
+
upb_Message* submsg,
|
7413
|
+
const upb_MiniTableSub* subs,
|
7414
|
+
const upb_MiniTableField* field) {
|
6910
7415
|
const upb_MiniTable* subl = _upb_MiniTableSubs_MessageByField(subs, field);
|
6911
7416
|
UPB_ASSERT(subl);
|
6912
7417
|
return _upb_Decoder_DecodeGroup(d, ptr, submsg, subl,
|
@@ -6936,10 +7441,9 @@ static void _upb_Decoder_AddUnknownVarints(upb_Decoder* d, upb_Message* msg,
|
|
6936
7441
|
}
|
6937
7442
|
|
6938
7443
|
UPB_FORCEINLINE
|
6939
|
-
|
6940
|
-
|
6941
|
-
|
6942
|
-
wireval* val) {
|
7444
|
+
bool _upb_Decoder_CheckEnum(upb_Decoder* d, const char* ptr, upb_Message* msg,
|
7445
|
+
const upb_MiniTableEnum* e,
|
7446
|
+
const upb_MiniTableField* field, wireval* val) {
|
6943
7447
|
const uint32_t v = val->uint32_val;
|
6944
7448
|
|
6945
7449
|
if (UPB_LIKELY(upb_MiniTableEnum_CheckValue(e, v))) return true;
|
@@ -6973,9 +7477,10 @@ static const char* _upb_Decoder_DecodeEnumArray(upb_Decoder* d, const char* ptr,
|
|
6973
7477
|
}
|
6974
7478
|
|
6975
7479
|
UPB_FORCEINLINE
|
6976
|
-
|
6977
|
-
|
6978
|
-
|
7480
|
+
const char* _upb_Decoder_DecodeFixedPacked(upb_Decoder* d, const char* ptr,
|
7481
|
+
upb_Array* arr, wireval* val,
|
7482
|
+
const upb_MiniTableField* field,
|
7483
|
+
int lg2) {
|
6979
7484
|
int mask = (1 << lg2) - 1;
|
6980
7485
|
size_t count = val->size >> lg2;
|
6981
7486
|
if ((val->size & mask) != 0) {
|
@@ -7010,9 +7515,10 @@ static const char* _upb_Decoder_DecodeFixedPacked(
|
|
7010
7515
|
}
|
7011
7516
|
|
7012
7517
|
UPB_FORCEINLINE
|
7013
|
-
|
7014
|
-
|
7015
|
-
|
7518
|
+
const char* _upb_Decoder_DecodeVarintPacked(upb_Decoder* d, const char* ptr,
|
7519
|
+
upb_Array* arr, wireval* val,
|
7520
|
+
const upb_MiniTableField* field,
|
7521
|
+
int lg2) {
|
7016
7522
|
int scale = 1 << lg2;
|
7017
7523
|
int saved_limit = upb_EpsCopyInputStream_PushLimit(&d->input, ptr, val->size);
|
7018
7524
|
char* out = UPB_PTR_AT(upb_Array_MutableDataPtr(arr),
|
@@ -7255,7 +7761,7 @@ static const char* _upb_Decoder_DecodeToSubMessage(
|
|
7255
7761
|
// Set presence if necessary.
|
7256
7762
|
if (UPB_PRIVATE(_upb_MiniTableField_HasHasbit)(field)) {
|
7257
7763
|
UPB_PRIVATE(_upb_Message_SetHasbit)(msg, field);
|
7258
|
-
} else if (
|
7764
|
+
} else if (upb_MiniTableField_IsInOneof(field)) {
|
7259
7765
|
// Oneof case
|
7260
7766
|
uint32_t* oneof_case = UPB_PRIVATE(_upb_Message_OneofCasePtr)(msg, field);
|
7261
7767
|
if (op == kUpb_DecodeOp_SubMessage &&
|
@@ -7318,9 +7824,8 @@ const char* _upb_Decoder_CheckRequired(upb_Decoder* d, const char* ptr,
|
|
7318
7824
|
}
|
7319
7825
|
|
7320
7826
|
UPB_FORCEINLINE
|
7321
|
-
|
7322
|
-
|
7323
|
-
const upb_MiniTable* m) {
|
7827
|
+
bool _upb_Decoder_TryFastDispatch(upb_Decoder* d, const char** ptr,
|
7828
|
+
upb_Message* msg, const upb_MiniTable* m) {
|
7324
7829
|
#if UPB_FASTTABLE
|
7325
7830
|
if (m && m->UPB_PRIVATE(table_mask) != (unsigned char)-1) {
|
7326
7831
|
uint16_t tag = _upb_FastDecoder_LoadTag(*ptr);
|
@@ -7558,9 +8063,8 @@ static int _upb_Decoder_GetVarintOp(const upb_MiniTableField* field) {
|
|
7558
8063
|
}
|
7559
8064
|
|
7560
8065
|
UPB_FORCEINLINE
|
7561
|
-
|
7562
|
-
|
7563
|
-
int* op) {
|
8066
|
+
void _upb_Decoder_CheckUnlinked(upb_Decoder* d, const upb_MiniTable* mt,
|
8067
|
+
const upb_MiniTableField* field, int* op) {
|
7564
8068
|
// If sub-message is not linked, treat as unknown.
|
7565
8069
|
if (field->UPB_PRIVATE(mode) & kUpb_LabelFlags_IsExtension) return;
|
7566
8070
|
const upb_MiniTable* mt_sub =
|
@@ -7586,9 +8090,8 @@ static void _upb_Decoder_CheckUnlinked(upb_Decoder* d, const upb_MiniTable* mt,
|
|
7586
8090
|
}
|
7587
8091
|
|
7588
8092
|
UPB_FORCEINLINE
|
7589
|
-
|
7590
|
-
|
7591
|
-
int* op) {
|
8093
|
+
void _upb_Decoder_MaybeVerifyUtf8(upb_Decoder* d,
|
8094
|
+
const upb_MiniTableField* field, int* op) {
|
7592
8095
|
if ((field->UPB_ONLYBITS(mode) & kUpb_LabelFlags_IsAlternate) &&
|
7593
8096
|
UPB_UNLIKELY(d->options & kUpb_DecodeOption_AlwaysValidateUtf8))
|
7594
8097
|
*op = kUpb_DecodeOp_String;
|
@@ -7658,11 +8161,10 @@ static int _upb_Decoder_GetDelimitedOp(upb_Decoder* d, const upb_MiniTable* mt,
|
|
7658
8161
|
}
|
7659
8162
|
|
7660
8163
|
UPB_FORCEINLINE
|
7661
|
-
|
7662
|
-
|
7663
|
-
|
7664
|
-
|
7665
|
-
int* op) {
|
8164
|
+
const char* _upb_Decoder_DecodeWireValue(upb_Decoder* d, const char* ptr,
|
8165
|
+
const upb_MiniTable* mt,
|
8166
|
+
const upb_MiniTableField* field,
|
8167
|
+
int wire_type, wireval* val, int* op) {
|
7666
8168
|
static const unsigned kFixed32OkMask = (1 << kUpb_FieldType_Float) |
|
7667
8169
|
(1 << kUpb_FieldType_Fixed32) |
|
7668
8170
|
(1 << kUpb_FieldType_SFixed32);
|
@@ -7712,10 +8214,11 @@ static const char* _upb_Decoder_DecodeWireValue(upb_Decoder* d, const char* ptr,
|
|
7712
8214
|
}
|
7713
8215
|
|
7714
8216
|
UPB_FORCEINLINE
|
7715
|
-
|
7716
|
-
|
7717
|
-
|
7718
|
-
|
8217
|
+
const char* _upb_Decoder_DecodeKnownField(upb_Decoder* d, const char* ptr,
|
8218
|
+
upb_Message* msg,
|
8219
|
+
const upb_MiniTable* layout,
|
8220
|
+
const upb_MiniTableField* field,
|
8221
|
+
int op, wireval* val) {
|
7719
8222
|
const upb_MiniTableSub* subs = layout->UPB_PRIVATE(subs);
|
7720
8223
|
uint8_t mode = field->UPB_PRIVATE(mode);
|
7721
8224
|
|
@@ -7921,9 +8424,10 @@ static upb_DecodeStatus upb_Decoder_Decode(upb_Decoder* const decoder,
|
|
7921
8424
|
}
|
7922
8425
|
|
7923
8426
|
upb_DecodeStatus upb_Decode(const char* buf, size_t size, upb_Message* msg,
|
7924
|
-
const upb_MiniTable*
|
8427
|
+
const upb_MiniTable* mt,
|
7925
8428
|
const upb_ExtensionRegistry* extreg, int options,
|
7926
8429
|
upb_Arena* arena) {
|
8430
|
+
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
7927
8431
|
upb_Decoder decoder;
|
7928
8432
|
unsigned depth = (unsigned)options >> 16;
|
7929
8433
|
|
@@ -7945,7 +8449,42 @@ upb_DecodeStatus upb_Decode(const char* buf, size_t size, upb_Message* msg,
|
|
7945
8449
|
// (particularly parent_or_count).
|
7946
8450
|
UPB_PRIVATE(_upb_Arena_SwapIn)(&decoder.arena, arena);
|
7947
8451
|
|
7948
|
-
return upb_Decoder_Decode(&decoder, buf, msg,
|
8452
|
+
return upb_Decoder_Decode(&decoder, buf, msg, mt, arena);
|
8453
|
+
}
|
8454
|
+
|
8455
|
+
upb_DecodeStatus upb_DecodeLengthPrefixed(const char* buf, size_t size,
|
8456
|
+
upb_Message* msg,
|
8457
|
+
size_t* num_bytes_read,
|
8458
|
+
const upb_MiniTable* mt,
|
8459
|
+
const upb_ExtensionRegistry* extreg,
|
8460
|
+
int options, upb_Arena* arena) {
|
8461
|
+
// To avoid needing to make a Decoder just to decode the initial length,
|
8462
|
+
// hand-decode the leading varint for the message length here.
|
8463
|
+
uint64_t msg_len = 0;
|
8464
|
+
for (size_t i = 0;; ++i) {
|
8465
|
+
if (i >= size || i > 9) {
|
8466
|
+
return kUpb_DecodeStatus_Malformed;
|
8467
|
+
}
|
8468
|
+
uint64_t b = *buf;
|
8469
|
+
buf++;
|
8470
|
+
msg_len += (b & 0x7f) << (i * 7);
|
8471
|
+
if ((b & 0x80) == 0) {
|
8472
|
+
*num_bytes_read = i + 1 + msg_len;
|
8473
|
+
break;
|
8474
|
+
}
|
8475
|
+
}
|
8476
|
+
|
8477
|
+
// If the total number of bytes we would read (= the bytes from the varint
|
8478
|
+
// plus however many bytes that varint says we should read) is larger then the
|
8479
|
+
// input buffer then error as malformed.
|
8480
|
+
if (*num_bytes_read > size) {
|
8481
|
+
return kUpb_DecodeStatus_Malformed;
|
8482
|
+
}
|
8483
|
+
if (msg_len > INT32_MAX) {
|
8484
|
+
return kUpb_DecodeStatus_Malformed;
|
8485
|
+
}
|
8486
|
+
|
8487
|
+
return upb_Decode(buf, msg_len, msg, mt, extreg, options, arena);
|
7949
8488
|
}
|
7950
8489
|
|
7951
8490
|
#undef OP_FIXPCK_LG2
|
@@ -8032,7 +8571,7 @@ static void encode_growbuffer(upb_encstate* e, size_t bytes) {
|
|
8032
8571
|
/* Call to ensure that at least "bytes" bytes are available for writing at
|
8033
8572
|
* e->ptr. Returns false if the bytes could not be allocated. */
|
8034
8573
|
UPB_FORCEINLINE
|
8035
|
-
|
8574
|
+
void encode_reserve(upb_encstate* e, size_t bytes) {
|
8036
8575
|
if ((size_t)(e->ptr - e->buf) < bytes) {
|
8037
8576
|
encode_growbuffer(e, bytes);
|
8038
8577
|
return;
|
@@ -8071,7 +8610,7 @@ static void encode_longvarint(upb_encstate* e, uint64_t val) {
|
|
8071
8610
|
}
|
8072
8611
|
|
8073
8612
|
UPB_FORCEINLINE
|
8074
|
-
|
8613
|
+
void encode_varint(upb_encstate* e, uint64_t val) {
|
8075
8614
|
if (val < 128 && e->ptr != e->buf) {
|
8076
8615
|
--e->ptr;
|
8077
8616
|
*e->ptr = val;
|
@@ -8101,7 +8640,7 @@ static void encode_tag(upb_encstate* e, uint32_t field_number,
|
|
8101
8640
|
|
8102
8641
|
static void encode_fixedarray(upb_encstate* e, const upb_Array* arr,
|
8103
8642
|
size_t elem_size, uint32_t tag) {
|
8104
|
-
size_t bytes = arr
|
8643
|
+
size_t bytes = upb_Array_Size(arr) * elem_size;
|
8105
8644
|
const char* data = upb_Array_DataPtr(arr);
|
8106
8645
|
const char* ptr = data + bytes - elem_size;
|
8107
8646
|
|
@@ -8198,7 +8737,7 @@ static void encode_scalar(upb_encstate* e, const void* _field_mem,
|
|
8198
8737
|
return;
|
8199
8738
|
}
|
8200
8739
|
if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
|
8201
|
-
encode_tag(e, f
|
8740
|
+
encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_EndGroup);
|
8202
8741
|
encode_TaggedMessagePtr(e, submsg, subm, &size);
|
8203
8742
|
wire_type = kUpb_WireType_StartGroup;
|
8204
8743
|
e->depth++;
|
@@ -8224,7 +8763,7 @@ static void encode_scalar(upb_encstate* e, const void* _field_mem,
|
|
8224
8763
|
}
|
8225
8764
|
#undef CASE
|
8226
8765
|
|
8227
|
-
encode_tag(e, f
|
8766
|
+
encode_tag(e, upb_MiniTableField_Number(f), wire_type);
|
8228
8767
|
}
|
8229
8768
|
|
8230
8769
|
static void encode_array(upb_encstate* e, const upb_Message* msg,
|
@@ -8234,14 +8773,14 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
|
|
8234
8773
|
bool packed = upb_MiniTableField_IsPacked(f);
|
8235
8774
|
size_t pre_len = e->limit - e->ptr;
|
8236
8775
|
|
8237
|
-
if (arr == NULL || arr
|
8776
|
+
if (arr == NULL || upb_Array_Size(arr) == 0) {
|
8238
8777
|
return;
|
8239
8778
|
}
|
8240
8779
|
|
8241
8780
|
#define VARINT_CASE(ctype, encode) \
|
8242
8781
|
{ \
|
8243
8782
|
const ctype* start = upb_Array_DataPtr(arr); \
|
8244
|
-
const ctype* ptr = start + arr
|
8783
|
+
const ctype* ptr = start + upb_Array_Size(arr); \
|
8245
8784
|
uint32_t tag = \
|
8246
8785
|
packed ? 0 : (f->UPB_PRIVATE(number) << 3) | kUpb_WireType_Varint; \
|
8247
8786
|
do { \
|
@@ -8286,34 +8825,34 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
|
|
8286
8825
|
case kUpb_FieldType_String:
|
8287
8826
|
case kUpb_FieldType_Bytes: {
|
8288
8827
|
const upb_StringView* start = upb_Array_DataPtr(arr);
|
8289
|
-
const upb_StringView* ptr = start + arr
|
8828
|
+
const upb_StringView* ptr = start + upb_Array_Size(arr);
|
8290
8829
|
do {
|
8291
8830
|
ptr--;
|
8292
8831
|
encode_bytes(e, ptr->data, ptr->size);
|
8293
8832
|
encode_varint(e, ptr->size);
|
8294
|
-
encode_tag(e, f
|
8833
|
+
encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_Delimited);
|
8295
8834
|
} while (ptr != start);
|
8296
8835
|
return;
|
8297
8836
|
}
|
8298
8837
|
case kUpb_FieldType_Group: {
|
8299
8838
|
const upb_TaggedMessagePtr* start = upb_Array_DataPtr(arr);
|
8300
|
-
const upb_TaggedMessagePtr* ptr = start + arr
|
8839
|
+
const upb_TaggedMessagePtr* ptr = start + upb_Array_Size(arr);
|
8301
8840
|
const upb_MiniTable* subm =
|
8302
8841
|
upb_MiniTableSub_Message(subs[f->UPB_PRIVATE(submsg_index)]);
|
8303
8842
|
if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
|
8304
8843
|
do {
|
8305
8844
|
size_t size;
|
8306
8845
|
ptr--;
|
8307
|
-
encode_tag(e, f
|
8846
|
+
encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_EndGroup);
|
8308
8847
|
encode_TaggedMessagePtr(e, *ptr, subm, &size);
|
8309
|
-
encode_tag(e, f
|
8848
|
+
encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_StartGroup);
|
8310
8849
|
} while (ptr != start);
|
8311
8850
|
e->depth++;
|
8312
8851
|
return;
|
8313
8852
|
}
|
8314
8853
|
case kUpb_FieldType_Message: {
|
8315
8854
|
const upb_TaggedMessagePtr* start = upb_Array_DataPtr(arr);
|
8316
|
-
const upb_TaggedMessagePtr* ptr = start + arr
|
8855
|
+
const upb_TaggedMessagePtr* ptr = start + upb_Array_Size(arr);
|
8317
8856
|
const upb_MiniTable* subm =
|
8318
8857
|
upb_MiniTableSub_Message(subs[f->UPB_PRIVATE(submsg_index)]);
|
8319
8858
|
if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
|
@@ -8322,7 +8861,7 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
|
|
8322
8861
|
ptr--;
|
8323
8862
|
encode_TaggedMessagePtr(e, *ptr, subm, &size);
|
8324
8863
|
encode_varint(e, size);
|
8325
|
-
encode_tag(e, f
|
8864
|
+
encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_Delimited);
|
8326
8865
|
} while (ptr != start);
|
8327
8866
|
e->depth++;
|
8328
8867
|
return;
|
@@ -8332,15 +8871,15 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
|
|
8332
8871
|
|
8333
8872
|
if (packed) {
|
8334
8873
|
encode_varint(e, e->limit - e->ptr - pre_len);
|
8335
|
-
encode_tag(e, f
|
8874
|
+
encode_tag(e, upb_MiniTableField_Number(f), kUpb_WireType_Delimited);
|
8336
8875
|
}
|
8337
8876
|
}
|
8338
8877
|
|
8339
8878
|
static void encode_mapentry(upb_encstate* e, uint32_t number,
|
8340
8879
|
const upb_MiniTable* layout,
|
8341
8880
|
const upb_MapEntry* ent) {
|
8342
|
-
const upb_MiniTableField* key_field =
|
8343
|
-
const upb_MiniTableField* val_field =
|
8881
|
+
const upb_MiniTableField* key_field = upb_MiniTable_MapKey(layout);
|
8882
|
+
const upb_MiniTableField* val_field = upb_MiniTable_MapValue(layout);
|
8344
8883
|
size_t pre_len = e->limit - e->ptr;
|
8345
8884
|
size_t size;
|
8346
8885
|
encode_scalar(e, &ent->v, layout->UPB_PRIVATE(subs), val_field);
|
@@ -8356,7 +8895,7 @@ static void encode_map(upb_encstate* e, const upb_Message* msg,
|
|
8356
8895
|
const upb_Map* map = *UPB_PTR_AT(msg, f->UPB_PRIVATE(offset), const upb_Map*);
|
8357
8896
|
const upb_MiniTable* layout =
|
8358
8897
|
upb_MiniTableSub_Message(subs[f->UPB_PRIVATE(submsg_index)]);
|
8359
|
-
UPB_ASSERT(layout
|
8898
|
+
UPB_ASSERT(upb_MiniTable_FieldCount(layout) == 2);
|
8360
8899
|
|
8361
8900
|
if (!map || !upb_Map_Size(map)) return;
|
8362
8901
|
|
@@ -8367,7 +8906,7 @@ static void encode_map(upb_encstate* e, const upb_Message* msg,
|
|
8367
8906
|
map, &sorted);
|
8368
8907
|
upb_MapEntry ent;
|
8369
8908
|
while (_upb_sortedmap_next(&e->sorter, map, &sorted, &ent)) {
|
8370
|
-
encode_mapentry(e, f
|
8909
|
+
encode_mapentry(e, upb_MiniTableField_Number(f), layout, &ent);
|
8371
8910
|
}
|
8372
8911
|
_upb_mapsorter_popmap(&e->sorter, &sorted);
|
8373
8912
|
} else {
|
@@ -8378,7 +8917,7 @@ static void encode_map(upb_encstate* e, const upb_Message* msg,
|
|
8378
8917
|
upb_MapEntry ent;
|
8379
8918
|
_upb_map_fromkey(key, &ent.k, map->key_size);
|
8380
8919
|
_upb_map_fromvalue(val, &ent.v, map->val_size);
|
8381
|
-
encode_mapentry(e, f
|
8920
|
+
encode_mapentry(e, upb_MiniTableField_Number(f), layout, &ent);
|
8382
8921
|
}
|
8383
8922
|
}
|
8384
8923
|
}
|
@@ -8418,7 +8957,7 @@ static bool encode_shouldencode(upb_encstate* e, const upb_Message* msg,
|
|
8418
8957
|
} else {
|
8419
8958
|
// Field is in a oneof.
|
8420
8959
|
return UPB_PRIVATE(_upb_Message_GetOneofCase)(msg, f) ==
|
8421
|
-
f
|
8960
|
+
upb_MiniTableField_Number(f);
|
8422
8961
|
}
|
8423
8962
|
}
|
8424
8963
|
|
@@ -8444,7 +8983,7 @@ static void encode_field(upb_encstate* e, const upb_Message* msg,
|
|
8444
8983
|
static void encode_msgset_item(upb_encstate* e, const upb_Extension* ext) {
|
8445
8984
|
size_t size;
|
8446
8985
|
encode_tag(e, kUpb_MsgSet_Item, kUpb_WireType_EndGroup);
|
8447
|
-
encode_message(e, ext->data.
|
8986
|
+
encode_message(e, ext->data.msg_val,
|
8448
8987
|
upb_MiniTableExtension_GetSubMessage(ext->ext), &size);
|
8449
8988
|
encode_varint(e, size);
|
8450
8989
|
encode_tag(e, kUpb_MsgSet_Message, kUpb_WireType_Delimited);
|
@@ -8508,7 +9047,7 @@ static void encode_message(upb_encstate* e, const upb_Message* msg,
|
|
8508
9047
|
}
|
8509
9048
|
}
|
8510
9049
|
|
8511
|
-
if (m
|
9050
|
+
if (upb_MiniTable_FieldCount(m)) {
|
8512
9051
|
const upb_MiniTableField* f =
|
8513
9052
|
&m->UPB_PRIVATE(fields)[m->UPB_PRIVATE(field_count)];
|
8514
9053
|
const upb_MiniTableField* first = &m->UPB_PRIVATE(fields)[0];
|
@@ -8526,14 +9065,18 @@ static void encode_message(upb_encstate* e, const upb_Message* msg,
|
|
8526
9065
|
static upb_EncodeStatus upb_Encoder_Encode(upb_encstate* const encoder,
|
8527
9066
|
const upb_Message* const msg,
|
8528
9067
|
const upb_MiniTable* const l,
|
8529
|
-
char** const buf,
|
8530
|
-
|
9068
|
+
char** const buf, size_t* const size,
|
9069
|
+
bool prepend_len) {
|
8531
9070
|
// Unfortunately we must continue to perform hackery here because there are
|
8532
9071
|
// code paths which blindly copy the returned pointer without bothering to
|
8533
9072
|
// check for errors until much later (b/235839510). So we still set *buf to
|
8534
9073
|
// NULL on error and we still set it to non-NULL on a successful empty result.
|
8535
9074
|
if (UPB_SETJMP(encoder->err) == 0) {
|
8536
|
-
|
9075
|
+
size_t encoded_msg_size;
|
9076
|
+
encode_message(encoder, msg, l, &encoded_msg_size);
|
9077
|
+
if (prepend_len) {
|
9078
|
+
encode_varint(encoder, encoded_msg_size);
|
9079
|
+
}
|
8537
9080
|
*size = encoder->limit - encoder->ptr;
|
8538
9081
|
if (*size == 0) {
|
8539
9082
|
static char ch;
|
@@ -8552,9 +9095,10 @@ static upb_EncodeStatus upb_Encoder_Encode(upb_encstate* const encoder,
|
|
8552
9095
|
return encoder->status;
|
8553
9096
|
}
|
8554
9097
|
|
8555
|
-
upb_EncodeStatus
|
8556
|
-
|
8557
|
-
|
9098
|
+
static upb_EncodeStatus _upb_Encode(const upb_Message* msg,
|
9099
|
+
const upb_MiniTable* l, int options,
|
9100
|
+
upb_Arena* arena, char** buf, size_t* size,
|
9101
|
+
bool prepend_len) {
|
8558
9102
|
upb_encstate e;
|
8559
9103
|
unsigned depth = (unsigned)options >> 16;
|
8560
9104
|
|
@@ -8567,7 +9111,20 @@ upb_EncodeStatus upb_Encode(const upb_Message* msg, const upb_MiniTable* l,
|
|
8567
9111
|
e.options = options;
|
8568
9112
|
_upb_mapsorter_init(&e.sorter);
|
8569
9113
|
|
8570
|
-
return upb_Encoder_Encode(&e, msg, l, buf, size);
|
9114
|
+
return upb_Encoder_Encode(&e, msg, l, buf, size, prepend_len);
|
9115
|
+
}
|
9116
|
+
|
9117
|
+
upb_EncodeStatus upb_Encode(const upb_Message* msg, const upb_MiniTable* l,
|
9118
|
+
int options, upb_Arena* arena, char** buf,
|
9119
|
+
size_t* size) {
|
9120
|
+
return _upb_Encode(msg, l, options, arena, buf, size, false);
|
9121
|
+
}
|
9122
|
+
|
9123
|
+
upb_EncodeStatus upb_EncodeLengthPrefixed(const upb_Message* msg,
|
9124
|
+
const upb_MiniTable* l, int options,
|
9125
|
+
upb_Arena* arena, char** buf,
|
9126
|
+
size_t* size) {
|
9127
|
+
return _upb_Encode(msg, l, options, arena, buf, size, true);
|
8571
9128
|
}
|
8572
9129
|
|
8573
9130
|
// Fast decoder: ~3x the speed of decode.c, but requires x86-64/ARM64.
|
@@ -8617,7 +9174,7 @@ static const char* fastdecode_isdonefallback(UPB_PARSE_PARAMS) {
|
|
8617
9174
|
}
|
8618
9175
|
|
8619
9176
|
UPB_FORCEINLINE
|
8620
|
-
|
9177
|
+
const char* fastdecode_dispatch(UPB_PARSE_PARAMS) {
|
8621
9178
|
int overrun;
|
8622
9179
|
switch (upb_EpsCopyInputStream_IsDoneStatus(&d->input, ptr, &overrun)) {
|
8623
9180
|
case kUpb_IsDoneStatus_Done:
|
@@ -8639,7 +9196,7 @@ static const char* fastdecode_dispatch(UPB_PARSE_PARAMS) {
|
|
8639
9196
|
}
|
8640
9197
|
|
8641
9198
|
UPB_FORCEINLINE
|
8642
|
-
|
9199
|
+
bool fastdecode_checktag(uint16_t data, int tagbytes) {
|
8643
9200
|
if (tagbytes == 1) {
|
8644
9201
|
return (data & 0xff) == 0;
|
8645
9202
|
} else {
|
@@ -8648,7 +9205,7 @@ static bool fastdecode_checktag(uint16_t data, int tagbytes) {
|
|
8648
9205
|
}
|
8649
9206
|
|
8650
9207
|
UPB_FORCEINLINE
|
8651
|
-
|
9208
|
+
const char* fastdecode_longsize(const char* ptr, int* size) {
|
8652
9209
|
int i;
|
8653
9210
|
UPB_ASSERT(*size & 0x80);
|
8654
9211
|
*size &= 0xff;
|
@@ -8668,7 +9225,7 @@ static const char* fastdecode_longsize(const char* ptr, int* size) {
|
|
8668
9225
|
}
|
8669
9226
|
|
8670
9227
|
UPB_FORCEINLINE
|
8671
|
-
|
9228
|
+
const char* fastdecode_delimited(
|
8672
9229
|
upb_Decoder* d, const char* ptr,
|
8673
9230
|
upb_EpsCopyInputStream_ParseDelimitedFunc* func, void* ctx) {
|
8674
9231
|
ptr++;
|
@@ -8721,8 +9278,8 @@ typedef struct {
|
|
8721
9278
|
} fastdecode_nextret;
|
8722
9279
|
|
8723
9280
|
UPB_FORCEINLINE
|
8724
|
-
|
8725
|
-
|
9281
|
+
void* fastdecode_resizearr(upb_Decoder* d, void* dst, fastdecode_arr* farr,
|
9282
|
+
int valbytes) {
|
8726
9283
|
if (UPB_UNLIKELY(dst == farr->end)) {
|
8727
9284
|
size_t old_capacity = farr->arr->UPB_PRIVATE(capacity);
|
8728
9285
|
size_t old_bytes = old_capacity * valbytes;
|
@@ -8740,7 +9297,7 @@ static void* fastdecode_resizearr(upb_Decoder* d, void* dst,
|
|
8740
9297
|
}
|
8741
9298
|
|
8742
9299
|
UPB_FORCEINLINE
|
8743
|
-
|
9300
|
+
bool fastdecode_tagmatch(uint32_t tag, uint64_t data, int tagbytes) {
|
8744
9301
|
if (tagbytes == 1) {
|
8745
9302
|
return (uint8_t)tag == (uint8_t)data;
|
8746
9303
|
} else {
|
@@ -8749,19 +9306,17 @@ static bool fastdecode_tagmatch(uint32_t tag, uint64_t data, int tagbytes) {
|
|
8749
9306
|
}
|
8750
9307
|
|
8751
9308
|
UPB_FORCEINLINE
|
8752
|
-
|
8753
|
-
int valbytes) {
|
9309
|
+
void fastdecode_commitarr(void* dst, fastdecode_arr* farr, int valbytes) {
|
8754
9310
|
farr->arr->UPB_PRIVATE(size) =
|
8755
9311
|
(size_t)((char*)dst - (char*)upb_Array_MutableDataPtr(farr->arr)) /
|
8756
9312
|
valbytes;
|
8757
9313
|
}
|
8758
9314
|
|
8759
9315
|
UPB_FORCEINLINE
|
8760
|
-
|
8761
|
-
|
8762
|
-
|
8763
|
-
|
8764
|
-
int valbytes) {
|
9316
|
+
fastdecode_nextret fastdecode_nextrepeated(upb_Decoder* d, void* dst,
|
9317
|
+
const char** ptr,
|
9318
|
+
fastdecode_arr* farr, uint64_t data,
|
9319
|
+
int tagbytes, int valbytes) {
|
8765
9320
|
fastdecode_nextret ret;
|
8766
9321
|
dst = (char*)dst + valbytes;
|
8767
9322
|
|
@@ -8783,16 +9338,15 @@ static fastdecode_nextret fastdecode_nextrepeated(upb_Decoder* d, void* dst,
|
|
8783
9338
|
}
|
8784
9339
|
|
8785
9340
|
UPB_FORCEINLINE
|
8786
|
-
|
9341
|
+
void* fastdecode_fieldmem(upb_Message* msg, uint64_t data) {
|
8787
9342
|
size_t ofs = data >> 48;
|
8788
9343
|
return (char*)msg + ofs;
|
8789
9344
|
}
|
8790
9345
|
|
8791
9346
|
UPB_FORCEINLINE
|
8792
|
-
|
8793
|
-
|
8794
|
-
|
8795
|
-
int valbytes, upb_card card) {
|
9347
|
+
void* fastdecode_getfield(upb_Decoder* d, const char* ptr, upb_Message* msg,
|
9348
|
+
uint64_t* data, uint64_t* hasbits,
|
9349
|
+
fastdecode_arr* farr, int valbytes, upb_card card) {
|
8796
9350
|
switch (card) {
|
8797
9351
|
case CARD_s: {
|
8798
9352
|
uint8_t hasbit_index = *data >> 24;
|
@@ -8831,7 +9385,7 @@ static void* fastdecode_getfield(upb_Decoder* d, const char* ptr,
|
|
8831
9385
|
}
|
8832
9386
|
|
8833
9387
|
UPB_FORCEINLINE
|
8834
|
-
|
9388
|
+
bool fastdecode_flippacked(uint64_t* data, int tagbytes) {
|
8835
9389
|
*data ^= (0x2 ^ 0x0); // Patch data to match packed wiretype.
|
8836
9390
|
return fastdecode_checktag(*data, tagbytes);
|
8837
9391
|
}
|
@@ -8847,7 +9401,7 @@ static bool fastdecode_flippacked(uint64_t* data, int tagbytes) {
|
|
8847
9401
|
/* varint fields **************************************************************/
|
8848
9402
|
|
8849
9403
|
UPB_FORCEINLINE
|
8850
|
-
|
9404
|
+
uint64_t fastdecode_munge(uint64_t val, int valbytes, bool zigzag) {
|
8851
9405
|
if (valbytes == 1) {
|
8852
9406
|
return val != 0;
|
8853
9407
|
} else if (zigzag) {
|
@@ -8863,7 +9417,7 @@ static uint64_t fastdecode_munge(uint64_t val, int valbytes, bool zigzag) {
|
|
8863
9417
|
}
|
8864
9418
|
|
8865
9419
|
UPB_FORCEINLINE
|
8866
|
-
|
9420
|
+
const char* fastdecode_varint64(const char* ptr, uint64_t* val) {
|
8867
9421
|
ptr++;
|
8868
9422
|
*val = (uint8_t)ptr[-1];
|
8869
9423
|
if (UPB_UNLIKELY(*val & 0x80)) {
|
@@ -8938,8 +9492,8 @@ typedef struct {
|
|
8938
9492
|
} fastdecode_varintdata;
|
8939
9493
|
|
8940
9494
|
UPB_FORCEINLINE
|
8941
|
-
|
8942
|
-
|
9495
|
+
const char* fastdecode_topackedvarint(upb_EpsCopyInputStream* e,
|
9496
|
+
const char* ptr, void* ctx) {
|
8943
9497
|
upb_Decoder* d = (upb_Decoder*)e;
|
8944
9498
|
fastdecode_varintdata* data = ctx;
|
8945
9499
|
void* dst = data->dst;
|
@@ -9218,9 +9772,8 @@ static const char* fastdecode_longstring_noutf8(
|
|
9218
9772
|
}
|
9219
9773
|
|
9220
9774
|
UPB_FORCEINLINE
|
9221
|
-
|
9222
|
-
|
9223
|
-
upb_StringView* dst) {
|
9775
|
+
void fastdecode_docopy(upb_Decoder* d, const char* ptr, uint32_t size, int copy,
|
9776
|
+
char* data, size_t data_offset, upb_StringView* dst) {
|
9224
9777
|
d->arena.UPB_PRIVATE(ptr) += copy;
|
9225
9778
|
dst->data = data + data_offset;
|
9226
9779
|
UPB_UNPOISON_MEMORY_REGION(data, copy);
|
@@ -9451,8 +10004,8 @@ typedef struct {
|
|
9451
10004
|
} fastdecode_submsgdata;
|
9452
10005
|
|
9453
10006
|
UPB_FORCEINLINE
|
9454
|
-
|
9455
|
-
|
10007
|
+
const char* fastdecode_tosubmsg(upb_EpsCopyInputStream* e, const char* ptr,
|
10008
|
+
void* ctx) {
|
9456
10009
|
upb_Decoder* d = (upb_Decoder*)e;
|
9457
10010
|
fastdecode_submsgdata* submsg = ctx;
|
9458
10011
|
ptr = fastdecode_dispatch(d, ptr, submsg->msg, submsg->table, 0, 0);
|
@@ -9570,8 +10123,7 @@ UPB_NOINLINE UPB_PRIVATE(_upb_WireReader_LongVarint)
|
|
9570
10123
|
UPB_PRIVATE(_upb_WireReader_ReadLongVarint)(const char* ptr, uint64_t val) {
|
9571
10124
|
UPB_PRIVATE(_upb_WireReader_LongVarint) ret = {NULL, 0};
|
9572
10125
|
uint64_t byte;
|
9573
|
-
int i;
|
9574
|
-
for (i = 1; i < 10; i++) {
|
10126
|
+
for (int i = 1; i < 10; i++) {
|
9575
10127
|
byte = (uint8_t)ptr[i];
|
9576
10128
|
val += (byte - 1) << (i * 7);
|
9577
10129
|
if (!(byte & 0x80)) {
|
@@ -10603,15 +11155,291 @@ int upb_Unicode_ToUTF8(uint32_t cp, char* out) {
|
|
10603
11155
|
}
|
10604
11156
|
|
10605
11157
|
|
11158
|
+
#include <stdlib.h>
|
11159
|
+
|
11160
|
+
|
11161
|
+
// Must be last.
|
11162
|
+
|
11163
|
+
typedef struct upb_UnknownFields upb_UnknownFields;
|
11164
|
+
|
11165
|
+
typedef struct {
|
11166
|
+
uint32_t tag;
|
11167
|
+
union {
|
11168
|
+
uint64_t varint;
|
11169
|
+
uint64_t uint64;
|
11170
|
+
uint32_t uint32;
|
11171
|
+
upb_StringView delimited;
|
11172
|
+
upb_UnknownFields* group;
|
11173
|
+
} data;
|
11174
|
+
} upb_UnknownField;
|
11175
|
+
|
11176
|
+
struct upb_UnknownFields {
|
11177
|
+
size_t size;
|
11178
|
+
size_t capacity;
|
11179
|
+
upb_UnknownField* fields;
|
11180
|
+
};
|
11181
|
+
|
11182
|
+
typedef struct {
|
11183
|
+
upb_EpsCopyInputStream stream;
|
11184
|
+
upb_Arena* arena;
|
11185
|
+
upb_UnknownField* tmp;
|
11186
|
+
size_t tmp_size;
|
11187
|
+
int depth;
|
11188
|
+
upb_UnknownCompareResult status;
|
11189
|
+
jmp_buf err;
|
11190
|
+
} upb_UnknownField_Context;
|
11191
|
+
|
11192
|
+
UPB_NORETURN static void upb_UnknownFields_OutOfMemory(
|
11193
|
+
upb_UnknownField_Context* ctx) {
|
11194
|
+
ctx->status = kUpb_UnknownCompareResult_OutOfMemory;
|
11195
|
+
UPB_LONGJMP(ctx->err, 1);
|
11196
|
+
}
|
11197
|
+
|
11198
|
+
static void upb_UnknownFields_Grow(upb_UnknownField_Context* ctx,
|
11199
|
+
upb_UnknownField** base,
|
11200
|
+
upb_UnknownField** ptr,
|
11201
|
+
upb_UnknownField** end) {
|
11202
|
+
size_t old = (*ptr - *base);
|
11203
|
+
size_t new = UPB_MAX(4, old * 2);
|
11204
|
+
|
11205
|
+
*base = upb_Arena_Realloc(ctx->arena, *base, old * sizeof(**base),
|
11206
|
+
new * sizeof(**base));
|
11207
|
+
if (!*base) upb_UnknownFields_OutOfMemory(ctx);
|
11208
|
+
|
11209
|
+
*ptr = *base + old;
|
11210
|
+
*end = *base + new;
|
11211
|
+
}
|
11212
|
+
|
11213
|
+
// We have to implement our own sort here, since qsort() is not an in-order
|
11214
|
+
// sort. Here we use merge sort, the simplest in-order sort.
|
11215
|
+
static void upb_UnknownFields_Merge(upb_UnknownField* arr, size_t start,
|
11216
|
+
size_t mid, size_t end,
|
11217
|
+
upb_UnknownField* tmp) {
|
11218
|
+
memcpy(tmp, &arr[start], (end - start) * sizeof(*tmp));
|
11219
|
+
|
11220
|
+
upb_UnknownField* ptr1 = tmp;
|
11221
|
+
upb_UnknownField* end1 = &tmp[mid - start];
|
11222
|
+
upb_UnknownField* ptr2 = &tmp[mid - start];
|
11223
|
+
upb_UnknownField* end2 = &tmp[end - start];
|
11224
|
+
upb_UnknownField* out = &arr[start];
|
11225
|
+
|
11226
|
+
while (ptr1 < end1 && ptr2 < end2) {
|
11227
|
+
if (ptr1->tag <= ptr2->tag) {
|
11228
|
+
*out++ = *ptr1++;
|
11229
|
+
} else {
|
11230
|
+
*out++ = *ptr2++;
|
11231
|
+
}
|
11232
|
+
}
|
11233
|
+
|
11234
|
+
if (ptr1 < end1) {
|
11235
|
+
memcpy(out, ptr1, (end1 - ptr1) * sizeof(*out));
|
11236
|
+
} else if (ptr2 < end2) {
|
11237
|
+
memcpy(out, ptr1, (end2 - ptr2) * sizeof(*out));
|
11238
|
+
}
|
11239
|
+
}
|
11240
|
+
|
11241
|
+
static void upb_UnknownFields_SortRecursive(upb_UnknownField* arr, size_t start,
|
11242
|
+
size_t end, upb_UnknownField* tmp) {
|
11243
|
+
if (end - start > 1) {
|
11244
|
+
size_t mid = start + ((end - start) / 2);
|
11245
|
+
upb_UnknownFields_SortRecursive(arr, start, mid, tmp);
|
11246
|
+
upb_UnknownFields_SortRecursive(arr, mid, end, tmp);
|
11247
|
+
upb_UnknownFields_Merge(arr, start, mid, end, tmp);
|
11248
|
+
}
|
11249
|
+
}
|
11250
|
+
|
11251
|
+
static void upb_UnknownFields_Sort(upb_UnknownField_Context* ctx,
|
11252
|
+
upb_UnknownFields* fields) {
|
11253
|
+
if (ctx->tmp_size < fields->size) {
|
11254
|
+
const int oldsize = ctx->tmp_size * sizeof(*ctx->tmp);
|
11255
|
+
ctx->tmp_size = UPB_MAX(8, ctx->tmp_size);
|
11256
|
+
while (ctx->tmp_size < fields->size) ctx->tmp_size *= 2;
|
11257
|
+
const int newsize = ctx->tmp_size * sizeof(*ctx->tmp);
|
11258
|
+
ctx->tmp = upb_grealloc(ctx->tmp, oldsize, newsize);
|
11259
|
+
}
|
11260
|
+
upb_UnknownFields_SortRecursive(fields->fields, 0, fields->size, ctx->tmp);
|
11261
|
+
}
|
11262
|
+
|
11263
|
+
static upb_UnknownFields* upb_UnknownFields_DoBuild(
|
11264
|
+
upb_UnknownField_Context* ctx, const char** buf) {
|
11265
|
+
upb_UnknownField* arr_base = NULL;
|
11266
|
+
upb_UnknownField* arr_ptr = NULL;
|
11267
|
+
upb_UnknownField* arr_end = NULL;
|
11268
|
+
const char* ptr = *buf;
|
11269
|
+
uint32_t last_tag = 0;
|
11270
|
+
bool sorted = true;
|
11271
|
+
while (!upb_EpsCopyInputStream_IsDone(&ctx->stream, &ptr)) {
|
11272
|
+
uint32_t tag;
|
11273
|
+
ptr = upb_WireReader_ReadTag(ptr, &tag);
|
11274
|
+
UPB_ASSERT(tag <= UINT32_MAX);
|
11275
|
+
int wire_type = upb_WireReader_GetWireType(tag);
|
11276
|
+
if (wire_type == kUpb_WireType_EndGroup) break;
|
11277
|
+
if (tag < last_tag) sorted = false;
|
11278
|
+
last_tag = tag;
|
11279
|
+
|
11280
|
+
if (arr_ptr == arr_end) {
|
11281
|
+
upb_UnknownFields_Grow(ctx, &arr_base, &arr_ptr, &arr_end);
|
11282
|
+
}
|
11283
|
+
upb_UnknownField* field = arr_ptr;
|
11284
|
+
field->tag = tag;
|
11285
|
+
arr_ptr++;
|
11286
|
+
|
11287
|
+
switch (wire_type) {
|
11288
|
+
case kUpb_WireType_Varint:
|
11289
|
+
ptr = upb_WireReader_ReadVarint(ptr, &field->data.varint);
|
11290
|
+
break;
|
11291
|
+
case kUpb_WireType_64Bit:
|
11292
|
+
ptr = upb_WireReader_ReadFixed64(ptr, &field->data.uint64);
|
11293
|
+
break;
|
11294
|
+
case kUpb_WireType_32Bit:
|
11295
|
+
ptr = upb_WireReader_ReadFixed32(ptr, &field->data.uint32);
|
11296
|
+
break;
|
11297
|
+
case kUpb_WireType_Delimited: {
|
11298
|
+
int size;
|
11299
|
+
ptr = upb_WireReader_ReadSize(ptr, &size);
|
11300
|
+
const char* s_ptr = ptr;
|
11301
|
+
ptr = upb_EpsCopyInputStream_ReadStringAliased(&ctx->stream, &s_ptr,
|
11302
|
+
size);
|
11303
|
+
field->data.delimited.data = s_ptr;
|
11304
|
+
field->data.delimited.size = size;
|
11305
|
+
break;
|
11306
|
+
}
|
11307
|
+
case kUpb_WireType_StartGroup:
|
11308
|
+
if (--ctx->depth == 0) {
|
11309
|
+
ctx->status = kUpb_UnknownCompareResult_MaxDepthExceeded;
|
11310
|
+
UPB_LONGJMP(ctx->err, 1);
|
11311
|
+
}
|
11312
|
+
field->data.group = upb_UnknownFields_DoBuild(ctx, &ptr);
|
11313
|
+
ctx->depth++;
|
11314
|
+
break;
|
11315
|
+
default:
|
11316
|
+
UPB_UNREACHABLE();
|
11317
|
+
}
|
11318
|
+
}
|
11319
|
+
|
11320
|
+
*buf = ptr;
|
11321
|
+
upb_UnknownFields* ret = upb_Arena_Malloc(ctx->arena, sizeof(*ret));
|
11322
|
+
if (!ret) upb_UnknownFields_OutOfMemory(ctx);
|
11323
|
+
ret->fields = arr_base;
|
11324
|
+
ret->size = arr_ptr - arr_base;
|
11325
|
+
ret->capacity = arr_end - arr_base;
|
11326
|
+
if (!sorted) {
|
11327
|
+
upb_UnknownFields_Sort(ctx, ret);
|
11328
|
+
}
|
11329
|
+
return ret;
|
11330
|
+
}
|
11331
|
+
|
11332
|
+
// Builds a upb_UnknownFields data structure from the binary data in buf.
|
11333
|
+
static upb_UnknownFields* upb_UnknownFields_Build(upb_UnknownField_Context* ctx,
|
11334
|
+
const char* ptr,
|
11335
|
+
size_t size) {
|
11336
|
+
upb_EpsCopyInputStream_Init(&ctx->stream, &ptr, size, true);
|
11337
|
+
upb_UnknownFields* fields = upb_UnknownFields_DoBuild(ctx, &ptr);
|
11338
|
+
UPB_ASSERT(upb_EpsCopyInputStream_IsDone(&ctx->stream, &ptr) &&
|
11339
|
+
!upb_EpsCopyInputStream_IsError(&ctx->stream));
|
11340
|
+
return fields;
|
11341
|
+
}
|
11342
|
+
|
11343
|
+
// Compares two sorted upb_UnknownFields structures for equality.
|
11344
|
+
static bool upb_UnknownFields_IsEqual(const upb_UnknownFields* uf1,
|
11345
|
+
const upb_UnknownFields* uf2) {
|
11346
|
+
if (uf1->size != uf2->size) return false;
|
11347
|
+
for (size_t i = 0, n = uf1->size; i < n; i++) {
|
11348
|
+
upb_UnknownField* f1 = &uf1->fields[i];
|
11349
|
+
upb_UnknownField* f2 = &uf2->fields[i];
|
11350
|
+
if (f1->tag != f2->tag) return false;
|
11351
|
+
int wire_type = f1->tag & 7;
|
11352
|
+
switch (wire_type) {
|
11353
|
+
case kUpb_WireType_Varint:
|
11354
|
+
if (f1->data.varint != f2->data.varint) return false;
|
11355
|
+
break;
|
11356
|
+
case kUpb_WireType_64Bit:
|
11357
|
+
if (f1->data.uint64 != f2->data.uint64) return false;
|
11358
|
+
break;
|
11359
|
+
case kUpb_WireType_32Bit:
|
11360
|
+
if (f1->data.uint32 != f2->data.uint32) return false;
|
11361
|
+
break;
|
11362
|
+
case kUpb_WireType_Delimited:
|
11363
|
+
if (!upb_StringView_IsEqual(f1->data.delimited, f2->data.delimited)) {
|
11364
|
+
return false;
|
11365
|
+
}
|
11366
|
+
break;
|
11367
|
+
case kUpb_WireType_StartGroup:
|
11368
|
+
if (!upb_UnknownFields_IsEqual(f1->data.group, f2->data.group)) {
|
11369
|
+
return false;
|
11370
|
+
}
|
11371
|
+
break;
|
11372
|
+
default:
|
11373
|
+
UPB_UNREACHABLE();
|
11374
|
+
}
|
11375
|
+
}
|
11376
|
+
return true;
|
11377
|
+
}
|
11378
|
+
|
11379
|
+
static upb_UnknownCompareResult upb_UnknownField_DoCompare(
|
11380
|
+
upb_UnknownField_Context* ctx, const char* buf1, size_t size1,
|
11381
|
+
const char* buf2, size_t size2) {
|
11382
|
+
upb_UnknownCompareResult ret;
|
11383
|
+
// First build both unknown fields into a sorted data structure (similar
|
11384
|
+
// to the UnknownFieldSet in C++).
|
11385
|
+
upb_UnknownFields* uf1 = upb_UnknownFields_Build(ctx, buf1, size1);
|
11386
|
+
upb_UnknownFields* uf2 = upb_UnknownFields_Build(ctx, buf2, size2);
|
11387
|
+
|
11388
|
+
// Now perform the equality check on the sorted structures.
|
11389
|
+
if (upb_UnknownFields_IsEqual(uf1, uf2)) {
|
11390
|
+
ret = kUpb_UnknownCompareResult_Equal;
|
11391
|
+
} else {
|
11392
|
+
ret = kUpb_UnknownCompareResult_NotEqual;
|
11393
|
+
}
|
11394
|
+
return ret;
|
11395
|
+
}
|
11396
|
+
|
11397
|
+
static upb_UnknownCompareResult upb_UnknownField_Compare(
|
11398
|
+
upb_UnknownField_Context* const ctx, const char* const buf1,
|
11399
|
+
const size_t size1, const char* const buf2, const size_t size2) {
|
11400
|
+
upb_UnknownCompareResult ret;
|
11401
|
+
if (UPB_SETJMP(ctx->err) == 0) {
|
11402
|
+
ret = upb_UnknownField_DoCompare(ctx, buf1, size1, buf2, size2);
|
11403
|
+
} else {
|
11404
|
+
ret = ctx->status;
|
11405
|
+
UPB_ASSERT(ret != kUpb_UnknownCompareResult_Equal);
|
11406
|
+
}
|
11407
|
+
|
11408
|
+
upb_Arena_Free(ctx->arena);
|
11409
|
+
upb_gfree(ctx->tmp);
|
11410
|
+
return ret;
|
11411
|
+
}
|
11412
|
+
|
11413
|
+
upb_UnknownCompareResult UPB_PRIVATE(_upb_Message_UnknownFieldsAreEqual)(
|
11414
|
+
const char* buf1, size_t size1, const char* buf2, size_t size2,
|
11415
|
+
int max_depth) {
|
11416
|
+
if (size1 == 0 && size2 == 0) return kUpb_UnknownCompareResult_Equal;
|
11417
|
+
if (size1 == 0 || size2 == 0) return kUpb_UnknownCompareResult_NotEqual;
|
11418
|
+
if (memcmp(buf1, buf2, size1) == 0) return kUpb_UnknownCompareResult_Equal;
|
11419
|
+
|
11420
|
+
upb_UnknownField_Context ctx = {
|
11421
|
+
.arena = upb_Arena_New(),
|
11422
|
+
.depth = max_depth,
|
11423
|
+
.tmp = NULL,
|
11424
|
+
.tmp_size = 0,
|
11425
|
+
.status = kUpb_UnknownCompareResult_Equal,
|
11426
|
+
};
|
11427
|
+
|
11428
|
+
if (!ctx.arena) return kUpb_UnknownCompareResult_OutOfMemory;
|
11429
|
+
|
11430
|
+
return upb_UnknownField_Compare(&ctx, buf1, size1, buf2, size2);
|
11431
|
+
}
|
11432
|
+
|
11433
|
+
|
10606
11434
|
#include <string.h>
|
10607
11435
|
|
10608
11436
|
|
10609
11437
|
// Must be last.
|
10610
11438
|
|
10611
|
-
const
|
11439
|
+
const upb_Extension* UPB_PRIVATE(_upb_Message_Getext)(
|
10612
11440
|
const struct upb_Message* msg, const upb_MiniTableExtension* e) {
|
10613
11441
|
size_t n;
|
10614
|
-
const
|
11442
|
+
const upb_Extension* ext = UPB_PRIVATE(_upb_Message_Getexts)(msg, &n);
|
10615
11443
|
|
10616
11444
|
// For now we use linear search exclusively to find extensions.
|
10617
11445
|
// If this becomes an issue due to messages with lots of extensions,
|
@@ -10625,11 +11453,11 @@ const struct upb_Extension* UPB_PRIVATE(_upb_Message_Getext)(
|
|
10625
11453
|
return NULL;
|
10626
11454
|
}
|
10627
11455
|
|
10628
|
-
const
|
11456
|
+
const upb_Extension* UPB_PRIVATE(_upb_Message_Getexts)(
|
10629
11457
|
const struct upb_Message* msg, size_t* count) {
|
10630
|
-
upb_Message_Internal* in = msg
|
11458
|
+
upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
|
10631
11459
|
if (in) {
|
10632
|
-
*count = (in->size - in->ext_begin) / sizeof(
|
11460
|
+
*count = (in->size - in->ext_begin) / sizeof(upb_Extension);
|
10633
11461
|
return UPB_PTR_AT(in, in->ext_begin, void);
|
10634
11462
|
} else {
|
10635
11463
|
*count = 0;
|
@@ -10637,17 +11465,16 @@ const struct upb_Extension* UPB_PRIVATE(_upb_Message_Getexts)(
|
|
10637
11465
|
}
|
10638
11466
|
}
|
10639
11467
|
|
10640
|
-
|
11468
|
+
upb_Extension* UPB_PRIVATE(_upb_Message_GetOrCreateExtension)(
|
10641
11469
|
struct upb_Message* msg, const upb_MiniTableExtension* e, upb_Arena* a) {
|
10642
|
-
|
10643
|
-
(struct upb_Extension*)UPB_PRIVATE(_upb_Message_Getext)(msg, e);
|
11470
|
+
upb_Extension* ext = (upb_Extension*)UPB_PRIVATE(_upb_Message_Getext)(msg, e);
|
10644
11471
|
if (ext) return ext;
|
10645
|
-
if (!UPB_PRIVATE(_upb_Message_Realloc)(msg, sizeof(
|
11472
|
+
if (!UPB_PRIVATE(_upb_Message_Realloc)(msg, sizeof(upb_Extension), a))
|
10646
11473
|
return NULL;
|
10647
|
-
upb_Message_Internal* in = msg
|
10648
|
-
in->ext_begin -= sizeof(
|
11474
|
+
upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
|
11475
|
+
in->ext_begin -= sizeof(upb_Extension);
|
10649
11476
|
ext = UPB_PTR_AT(in, in->ext_begin, void);
|
10650
|
-
memset(ext, 0, sizeof(
|
11477
|
+
memset(ext, 0, sizeof(upb_Extension));
|
10651
11478
|
ext->ext = e;
|
10652
11479
|
return ext;
|
10653
11480
|
}
|
@@ -10667,7 +11494,7 @@ bool UPB_PRIVATE(_upb_Message_Realloc)(struct upb_Message* msg, size_t need,
|
|
10667
11494
|
upb_Arena* a) {
|
10668
11495
|
const size_t overhead = sizeof(upb_Message_Internal);
|
10669
11496
|
|
10670
|
-
upb_Message_Internal* in = msg
|
11497
|
+
upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
|
10671
11498
|
if (!in) {
|
10672
11499
|
// No internal data, allocate from scratch.
|
10673
11500
|
size_t size = UPB_MAX(128, upb_Log2CeilingSize(need + overhead));
|
@@ -10677,7 +11504,7 @@ bool UPB_PRIVATE(_upb_Message_Realloc)(struct upb_Message* msg, size_t need,
|
|
10677
11504
|
in->size = size;
|
10678
11505
|
in->unknown_end = overhead;
|
10679
11506
|
in->ext_begin = size;
|
10680
|
-
msg
|
11507
|
+
UPB_PRIVATE(_upb_Message_SetInternal)(msg, in);
|
10681
11508
|
} else if (in->ext_begin - in->unknown_end < need) {
|
10682
11509
|
// Internal data is too small, reallocate.
|
10683
11510
|
size_t new_size = upb_Log2CeilingSize(in->size + need);
|
@@ -10693,13 +11520,30 @@ bool UPB_PRIVATE(_upb_Message_Realloc)(struct upb_Message* msg, size_t need,
|
|
10693
11520
|
}
|
10694
11521
|
in->ext_begin = new_ext_begin;
|
10695
11522
|
in->size = new_size;
|
10696
|
-
msg
|
11523
|
+
UPB_PRIVATE(_upb_Message_SetInternal)(msg, in);
|
10697
11524
|
}
|
10698
11525
|
|
10699
11526
|
UPB_ASSERT(in->ext_begin - in->unknown_end >= need);
|
10700
11527
|
return true;
|
10701
11528
|
}
|
10702
11529
|
|
11530
|
+
#if UPB_TRACING_ENABLED
|
11531
|
+
static void (*_new_message_trace_handler)(const upb_MiniTable*,
|
11532
|
+
const upb_Arena*);
|
11533
|
+
|
11534
|
+
void UPB_PRIVATE(upb_Message_SetNewMessageTraceHandler)(
|
11535
|
+
void (*new_message_trace_handler)(const upb_MiniTable*, const upb_Arena*)) {
|
11536
|
+
_new_message_trace_handler = new_message_trace_handler;
|
11537
|
+
}
|
11538
|
+
|
11539
|
+
void UPB_PRIVATE(upb_Message_LogNewMessage)(const upb_MiniTable* mini_table,
|
11540
|
+
const upb_Arena* arena) {
|
11541
|
+
if (_new_message_trace_handler) {
|
11542
|
+
_new_message_trace_handler(mini_table, arena);
|
11543
|
+
}
|
11544
|
+
}
|
11545
|
+
#endif
|
11546
|
+
|
10703
11547
|
|
10704
11548
|
const char _kUpb_ToBase92[] = {
|
10705
11549
|
' ', '!', '#', '$', '%', '&', '(', ')', '*', '+', ',', '-', '.', '/',
|
@@ -11729,7 +12573,11 @@ const upb_EnumValueDef* upb_EnumDef_Value(const upb_EnumDef* e, int i) {
|
|
11729
12573
|
}
|
11730
12574
|
|
11731
12575
|
bool upb_EnumDef_IsClosed(const upb_EnumDef* e) {
|
11732
|
-
if (
|
12576
|
+
if (UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN) return false;
|
12577
|
+
return upb_EnumDef_IsSpecifiedAsClosed(e);
|
12578
|
+
}
|
12579
|
+
|
12580
|
+
bool upb_EnumDef_IsSpecifiedAsClosed(const upb_EnumDef* e) {
|
11733
12581
|
return UPB_DESC(FeatureSet_enum_type)(e->resolved_features) ==
|
11734
12582
|
UPB_DESC(FeatureSet_CLOSED);
|
11735
12583
|
}
|
@@ -12035,15 +12883,10 @@ static void create_enumvaldef(upb_DefBuilder* ctx, const char* prefix,
|
|
12035
12883
|
static void _upb_EnumValueDef_CheckZeroValue(upb_DefBuilder* ctx,
|
12036
12884
|
const upb_EnumDef* e,
|
12037
12885
|
const upb_EnumValueDef* v, int n) {
|
12038
|
-
|
12039
|
-
|
12040
|
-
// When the special UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3 is enabled, we have to
|
12041
|
-
// exempt proto2 enums from this check, even when we are treating them as
|
12886
|
+
// When the special UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN is enabled, we have to
|
12887
|
+
// exempt closed enums from this check, even when we are treating them as
|
12042
12888
|
// open.
|
12043
|
-
if (
|
12044
|
-
upb_FileDef_Syntax(upb_EnumDef_File(e)) == kUpb_Syntax_Proto2) {
|
12045
|
-
return;
|
12046
|
-
}
|
12889
|
+
if (upb_EnumDef_IsSpecifiedAsClosed(e) || n == 0 || v[0].number == 0) return;
|
12047
12890
|
|
12048
12891
|
_upb_DefBuilder_Errf(ctx, "for open enums, the first value must be zero (%s)",
|
12049
12892
|
upb_EnumDef_FullName(e));
|
@@ -12225,27 +13068,16 @@ upb_CType upb_FieldDef_CType(const upb_FieldDef* f) {
|
|
12225
13068
|
return upb_FieldType_CType(f->type_);
|
12226
13069
|
}
|
12227
13070
|
|
12228
|
-
upb_FieldType upb_FieldDef_Type(const upb_FieldDef* f) {
|
12229
|
-
// TODO: remove once we can deprecate kUpb_FieldType_Group.
|
12230
|
-
if (f->type_ == kUpb_FieldType_Message &&
|
12231
|
-
UPB_DESC(FeatureSet_message_encoding)(f->resolved_features) ==
|
12232
|
-
UPB_DESC(FeatureSet_DELIMITED)) {
|
12233
|
-
return kUpb_FieldType_Group;
|
12234
|
-
}
|
12235
|
-
return f->type_;
|
12236
|
-
}
|
13071
|
+
upb_FieldType upb_FieldDef_Type(const upb_FieldDef* f) { return f->type_; }
|
12237
13072
|
|
12238
13073
|
uint32_t upb_FieldDef_Index(const upb_FieldDef* f) { return f->index_; }
|
12239
13074
|
|
12240
|
-
|
12241
|
-
|
12242
|
-
if (UPB_DESC(FeatureSet_field_presence)(f->resolved_features) ==
|
12243
|
-
UPB_DESC(FeatureSet_LEGACY_REQUIRED)) {
|
12244
|
-
return kUpb_Label_Required;
|
12245
|
-
}
|
12246
|
-
return f->label_;
|
13075
|
+
uint32_t upb_FieldDef_LayoutIndex(const upb_FieldDef* f) {
|
13076
|
+
return f->layout_index;
|
12247
13077
|
}
|
12248
13078
|
|
13079
|
+
upb_Label upb_FieldDef_Label(const upb_FieldDef* f) { return f->label_; }
|
13080
|
+
|
12249
13081
|
uint32_t upb_FieldDef_Number(const upb_FieldDef* f) { return f->number_; }
|
12250
13082
|
|
12251
13083
|
bool upb_FieldDef_IsExtension(const upb_FieldDef* f) { return f->is_extension; }
|
@@ -12376,6 +13208,40 @@ bool _upb_FieldDef_ValidateUtf8(const upb_FieldDef* f) {
|
|
12376
13208
|
UPB_DESC(FeatureSet_VERIFY);
|
12377
13209
|
}
|
12378
13210
|
|
13211
|
+
bool _upb_FieldDef_IsGroupLike(const upb_FieldDef* f) {
|
13212
|
+
// Groups are always tag-delimited.
|
13213
|
+
if (UPB_DESC(FeatureSet_message_encoding)(upb_FieldDef_ResolvedFeatures(f)) !=
|
13214
|
+
UPB_DESC(FeatureSet_DELIMITED)) {
|
13215
|
+
return false;
|
13216
|
+
}
|
13217
|
+
|
13218
|
+
const upb_MessageDef* msg = upb_FieldDef_MessageSubDef(f);
|
13219
|
+
|
13220
|
+
// Group fields always are always the lowercase type name.
|
13221
|
+
const char* mname = upb_MessageDef_Name(msg);
|
13222
|
+
const char* fname = upb_FieldDef_Name(f);
|
13223
|
+
size_t name_size = strlen(fname);
|
13224
|
+
if (name_size != strlen(mname)) return false;
|
13225
|
+
for (size_t i = 0; i < name_size; ++i) {
|
13226
|
+
if ((mname[i] | 0x20) != fname[i]) {
|
13227
|
+
// Case-insensitive ascii comparison.
|
13228
|
+
return false;
|
13229
|
+
}
|
13230
|
+
}
|
13231
|
+
|
13232
|
+
if (upb_MessageDef_File(msg) != upb_FieldDef_File(f)) {
|
13233
|
+
return false;
|
13234
|
+
}
|
13235
|
+
|
13236
|
+
// Group messages are always defined in the same scope as the field. File
|
13237
|
+
// level extensions will compare NULL == NULL here, which is why the file
|
13238
|
+
// comparison above is necessary to ensure both come from the same file.
|
13239
|
+
return upb_FieldDef_IsExtension(f) ? upb_FieldDef_ExtensionScope(f) ==
|
13240
|
+
upb_MessageDef_ContainingType(msg)
|
13241
|
+
: upb_FieldDef_ContainingType(f) ==
|
13242
|
+
upb_MessageDef_ContainingType(msg);
|
13243
|
+
}
|
13244
|
+
|
12379
13245
|
uint64_t _upb_FieldDef_Modifiers(const upb_FieldDef* f) {
|
12380
13246
|
uint64_t out = upb_FieldDef_IsPacked(f) ? kUpb_FieldModifier_IsPacked : 0;
|
12381
13247
|
|
@@ -12707,7 +13573,6 @@ static void _upb_FieldDef_Create(upb_DefBuilder* ctx, const char* prefix,
|
|
12707
13573
|
|
12708
13574
|
const upb_StringView name = UPB_DESC(FieldDescriptorProto_name)(field_proto);
|
12709
13575
|
f->full_name = _upb_DefBuilder_MakeFullName(ctx, prefix, name);
|
12710
|
-
f->label_ = (int)UPB_DESC(FieldDescriptorProto_label)(field_proto);
|
12711
13576
|
f->number_ = UPB_DESC(FieldDescriptorProto_number)(field_proto);
|
12712
13577
|
f->is_proto3_optional =
|
12713
13578
|
UPB_DESC(FieldDescriptorProto_proto3_optional)(field_proto);
|
@@ -12753,6 +13618,14 @@ static void _upb_FieldDef_Create(upb_DefBuilder* ctx, const char* prefix,
|
|
12753
13618
|
f->resolved_features = _upb_DefBuilder_DoResolveFeatures(
|
12754
13619
|
ctx, parent_features, unresolved_features, implicit);
|
12755
13620
|
|
13621
|
+
f->label_ = (int)UPB_DESC(FieldDescriptorProto_label)(field_proto);
|
13622
|
+
if (f->label_ == kUpb_Label_Optional &&
|
13623
|
+
// TODO: remove once we can deprecate kUpb_Label_Required.
|
13624
|
+
UPB_DESC(FeatureSet_field_presence)(f->resolved_features) ==
|
13625
|
+
UPB_DESC(FeatureSet_LEGACY_REQUIRED)) {
|
13626
|
+
f->label_ = kUpb_Label_Required;
|
13627
|
+
}
|
13628
|
+
|
12756
13629
|
if (!UPB_DESC(FieldDescriptorProto_has_name)(field_proto)) {
|
12757
13630
|
_upb_DefBuilder_Errf(ctx, "field has no name");
|
12758
13631
|
}
|
@@ -12772,6 +13645,12 @@ static void _upb_FieldDef_Create(upb_DefBuilder* ctx, const char* prefix,
|
|
12772
13645
|
UPB_DESC(FieldDescriptorProto_has_type_name)(field_proto);
|
12773
13646
|
|
12774
13647
|
f->type_ = (int)UPB_DESC(FieldDescriptorProto_type)(field_proto);
|
13648
|
+
if (f->type_ == kUpb_FieldType_Message &&
|
13649
|
+
// TODO: remove once we can deprecate kUpb_FieldType_Group.
|
13650
|
+
UPB_DESC(FeatureSet_message_encoding)(f->resolved_features) ==
|
13651
|
+
UPB_DESC(FeatureSet_DELIMITED)) {
|
13652
|
+
f->type_ = kUpb_FieldType_Group;
|
13653
|
+
}
|
12775
13654
|
|
12776
13655
|
if (has_type) {
|
12777
13656
|
switch (f->type_) {
|
@@ -12821,10 +13700,11 @@ static void _upb_FieldDef_Create(upb_DefBuilder* ctx, const char* prefix,
|
|
12821
13700
|
|
12822
13701
|
f->has_presence =
|
12823
13702
|
(!upb_FieldDef_IsRepeated(f)) &&
|
12824
|
-
(f->
|
12825
|
-
|
12826
|
-
|
12827
|
-
|
13703
|
+
(f->is_extension ||
|
13704
|
+
(f->type_ == kUpb_FieldType_Message ||
|
13705
|
+
f->type_ == kUpb_FieldType_Group || upb_FieldDef_ContainingOneof(f) ||
|
13706
|
+
UPB_DESC(FeatureSet_field_presence)(f->resolved_features) !=
|
13707
|
+
UPB_DESC(FeatureSet_IMPLICIT)));
|
12828
13708
|
}
|
12829
13709
|
|
12830
13710
|
static void _upb_FieldDef_CreateExt(upb_DefBuilder* ctx, const char* prefix,
|
@@ -13260,6 +14140,17 @@ const upb_MiniTableExtension* _upb_FileDef_ExtensionMiniTable(
|
|
13260
14140
|
return f->ext_layouts[i];
|
13261
14141
|
}
|
13262
14142
|
|
14143
|
+
// Note: Import cycles are not allowed so this will terminate.
|
14144
|
+
bool upb_FileDef_Resolves(const upb_FileDef* f, const char* path) {
|
14145
|
+
if (!strcmp(f->name, path)) return true;
|
14146
|
+
|
14147
|
+
for (int i = 0; i < upb_FileDef_PublicDependencyCount(f); i++) {
|
14148
|
+
const upb_FileDef* dep = upb_FileDef_PublicDependency(f, i);
|
14149
|
+
if (upb_FileDef_Resolves(dep, path)) return true;
|
14150
|
+
}
|
14151
|
+
return false;
|
14152
|
+
}
|
14153
|
+
|
13263
14154
|
static char* strviewdup(upb_DefBuilder* ctx, upb_StringView view) {
|
13264
14155
|
char* ret = upb_strdup2(view.data, view.size, _upb_DefBuilder_Arena(ctx));
|
13265
14156
|
if (!ret) _upb_DefBuilder_OomErr(ctx);
|
@@ -13311,20 +14202,35 @@ const UPB_DESC(FeatureSet*)
|
|
13311
14202
|
size_t n;
|
13312
14203
|
const UPB_DESC(FeatureSetDefaults_FeatureSetEditionDefault)* const* d =
|
13313
14204
|
UPB_DESC(FeatureSetDefaults_defaults)(defaults, &n);
|
13314
|
-
const UPB_DESC(
|
14205
|
+
const UPB_DESC(FeatureSetDefaults_FeatureSetEditionDefault)* result = NULL;
|
13315
14206
|
for (size_t i = 0; i < n; i++) {
|
13316
14207
|
if (UPB_DESC(FeatureSetDefaults_FeatureSetEditionDefault_edition)(d[i]) >
|
13317
14208
|
edition) {
|
13318
14209
|
break;
|
13319
14210
|
}
|
13320
|
-
|
14211
|
+
result = d[i];
|
13321
14212
|
}
|
13322
|
-
if (
|
14213
|
+
if (result == NULL) {
|
13323
14214
|
_upb_DefBuilder_Errf(ctx, "No valid default found for edition %s",
|
13324
14215
|
upb_FileDef_EditionName(edition));
|
13325
14216
|
return NULL;
|
13326
14217
|
}
|
13327
|
-
|
14218
|
+
|
14219
|
+
// Merge the fixed and overridable features to get the edition's default
|
14220
|
+
// feature set.
|
14221
|
+
const UPB_DESC(FeatureSet)* fixed = UPB_DESC(
|
14222
|
+
FeatureSetDefaults_FeatureSetEditionDefault_fixed_features)(result);
|
14223
|
+
const UPB_DESC(FeatureSet)* overridable = UPB_DESC(
|
14224
|
+
FeatureSetDefaults_FeatureSetEditionDefault_overridable_features)(result);
|
14225
|
+
if (!fixed && !overridable) {
|
14226
|
+
_upb_DefBuilder_Errf(ctx, "No valid default found for edition %s",
|
14227
|
+
upb_FileDef_EditionName(edition));
|
14228
|
+
return NULL;
|
14229
|
+
} else if (!fixed) {
|
14230
|
+
return overridable;
|
14231
|
+
}
|
14232
|
+
return _upb_DefBuilder_DoResolveFeatures(ctx, fixed, overridable,
|
14233
|
+
/*is_implicit=*/true);
|
13328
14234
|
}
|
13329
14235
|
|
13330
14236
|
// Allocate and initialize one file def, and add it to the context object.
|
@@ -14026,7 +14932,15 @@ make:
|
|
14026
14932
|
|
14027
14933
|
bool upb_Message_SetFieldByDef(upb_Message* msg, const upb_FieldDef* f,
|
14028
14934
|
upb_MessageValue val, upb_Arena* a) {
|
14029
|
-
|
14935
|
+
const upb_MiniTableField* m_f = upb_FieldDef_MiniTable(f);
|
14936
|
+
|
14937
|
+
if (upb_MiniTableField_IsExtension(m_f)) {
|
14938
|
+
return upb_Message_SetExtension(msg, (const upb_MiniTableExtension*)m_f,
|
14939
|
+
&val, a);
|
14940
|
+
} else {
|
14941
|
+
upb_Message_SetBaseField(msg, m_f, &val);
|
14942
|
+
return true;
|
14943
|
+
}
|
14030
14944
|
}
|
14031
14945
|
|
14032
14946
|
void upb_Message_ClearFieldByDef(upb_Message* msg, const upb_FieldDef* f) {
|
@@ -14046,19 +14960,20 @@ void upb_Message_ClearByDef(upb_Message* msg, const upb_MessageDef* m) {
|
|
14046
14960
|
bool upb_Message_Next(const upb_Message* msg, const upb_MessageDef* m,
|
14047
14961
|
const upb_DefPool* ext_pool, const upb_FieldDef** out_f,
|
14048
14962
|
upb_MessageValue* out_val, size_t* iter) {
|
14963
|
+
const upb_MiniTable* mt = upb_MessageDef_MiniTable(m);
|
14049
14964
|
size_t i = *iter;
|
14050
|
-
size_t n =
|
14965
|
+
size_t n = upb_MiniTable_FieldCount(mt);
|
14966
|
+
const upb_MessageValue zero = {0};
|
14051
14967
|
UPB_UNUSED(ext_pool);
|
14052
14968
|
|
14053
14969
|
// Iterate over normal fields, returning the first one that is set.
|
14054
14970
|
while (++i < n) {
|
14055
|
-
const
|
14056
|
-
|
14057
|
-
upb_MessageValue val = upb_Message_GetFieldByDef(msg, f);
|
14971
|
+
const upb_MiniTableField* field = upb_MiniTable_GetFieldByIndex(mt, i);
|
14972
|
+
upb_MessageValue val = upb_Message_GetField(msg, field, zero);
|
14058
14973
|
|
14059
14974
|
// Skip field if unset or empty.
|
14060
14975
|
if (upb_MiniTableField_HasPresence(field)) {
|
14061
|
-
if (!
|
14976
|
+
if (!upb_Message_HasBaseField(msg, field)) continue;
|
14062
14977
|
} else {
|
14063
14978
|
switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(field)) {
|
14064
14979
|
case kUpb_FieldMode_Map:
|
@@ -14075,7 +14990,8 @@ bool upb_Message_Next(const upb_Message* msg, const upb_MessageDef* m,
|
|
14075
14990
|
}
|
14076
14991
|
|
14077
14992
|
*out_val = val;
|
14078
|
-
*out_f =
|
14993
|
+
*out_f =
|
14994
|
+
upb_MessageDef_FindFieldByNumber(m, upb_MiniTableField_Number(field));
|
14079
14995
|
*iter = i;
|
14080
14996
|
return true;
|
14081
14997
|
}
|
@@ -14539,7 +15455,10 @@ void _upb_MessageDef_InsertField(upb_DefBuilder* ctx, upb_MessageDef* m,
|
|
14539
15455
|
_upb_MessageDef_Insert(m, shortname, shortnamelen, field_v, ctx->arena);
|
14540
15456
|
if (!ok) _upb_DefBuilder_OomErr(ctx);
|
14541
15457
|
|
14542
|
-
|
15458
|
+
bool skip_json_conflicts =
|
15459
|
+
UPB_DESC(MessageOptions_deprecated_legacy_json_field_conflicts)(
|
15460
|
+
upb_MessageDef_Options(m));
|
15461
|
+
if (!skip_json_conflicts && strcmp(shortname, json_name) != 0 &&
|
14543
15462
|
UPB_DESC(FeatureSet_json_format)(m->resolved_features) ==
|
14544
15463
|
UPB_DESC(FeatureSet_ALLOW) &&
|
14545
15464
|
upb_strtable_lookup(&m->ntof, json_name, &v)) {
|
@@ -14549,14 +15468,16 @@ void _upb_MessageDef_InsertField(upb_DefBuilder* ctx, upb_MessageDef* m,
|
|
14549
15468
|
}
|
14550
15469
|
|
14551
15470
|
if (upb_strtable_lookup(&m->jtof, json_name, &v)) {
|
14552
|
-
|
15471
|
+
if (!skip_json_conflicts) {
|
15472
|
+
_upb_DefBuilder_Errf(ctx, "duplicate json_name (%s)", json_name);
|
15473
|
+
}
|
15474
|
+
} else {
|
15475
|
+
const size_t json_size = strlen(json_name);
|
15476
|
+
ok = upb_strtable_insert(&m->jtof, json_name, json_size,
|
15477
|
+
upb_value_constptr(f), ctx->arena);
|
15478
|
+
if (!ok) _upb_DefBuilder_OomErr(ctx);
|
14553
15479
|
}
|
14554
15480
|
|
14555
|
-
const size_t json_size = strlen(json_name);
|
14556
|
-
ok = upb_strtable_insert(&m->jtof, json_name, json_size,
|
14557
|
-
upb_value_constptr(f), ctx->arena);
|
14558
|
-
if (!ok) _upb_DefBuilder_OomErr(ctx);
|
14559
|
-
|
14560
15481
|
if (upb_inttable_lookup(&m->itof, field_number, NULL)) {
|
14561
15482
|
_upb_DefBuilder_Errf(ctx, "duplicate field number (%u)", field_number);
|
14562
15483
|
}
|
@@ -14570,7 +15491,7 @@ void _upb_MessageDef_CreateMiniTable(upb_DefBuilder* ctx, upb_MessageDef* m) {
|
|
14570
15491
|
m->layout = _upb_MessageDef_MakeMiniTable(ctx, m);
|
14571
15492
|
} else {
|
14572
15493
|
m->layout = upb_MiniTableFile_Message(ctx->layout, ctx->msg_count++);
|
14573
|
-
UPB_ASSERT(m->field_count == m->layout
|
15494
|
+
UPB_ASSERT(m->field_count == upb_MiniTable_FieldCount(m->layout));
|
14574
15495
|
|
14575
15496
|
// We don't need the result of this call, but it will assign layout_index
|
14576
15497
|
// for all the fields in O(n lg n) time.
|
@@ -14628,7 +15549,7 @@ void _upb_MessageDef_LinkMiniTable(upb_DefBuilder* ctx,
|
|
14628
15549
|
for (int i = 0; i < m->field_count; i++) {
|
14629
15550
|
const upb_FieldDef* f = upb_MessageDef_Field(m, i);
|
14630
15551
|
const int layout_index = _upb_FieldDef_LayoutIndex(f);
|
14631
|
-
UPB_ASSERT(layout_index < m->layout
|
15552
|
+
UPB_ASSERT(layout_index < upb_MiniTable_FieldCount(m->layout));
|
14632
15553
|
const upb_MiniTableField* mt_f =
|
14633
15554
|
&m->layout->UPB_PRIVATE(fields)[layout_index];
|
14634
15555
|
UPB_ASSERT(upb_FieldDef_Type(f) == upb_MiniTableField_Type(mt_f));
|
@@ -15394,7 +16315,7 @@ upb_ServiceDef* _upb_ServiceDefs_New(upb_DefBuilder* ctx, int n,
|
|
15394
16315
|
#undef UPB_ASAN
|
15395
16316
|
#undef UPB_ASAN_GUARD_SIZE
|
15396
16317
|
#undef UPB_CLANG_ASAN
|
15397
|
-
#undef
|
16318
|
+
#undef UPB_TREAT_CLOSED_ENUMS_LIKE_OPEN
|
15398
16319
|
#undef UPB_DEPRECATED
|
15399
16320
|
#undef UPB_GNUC_MIN
|
15400
16321
|
#undef UPB_DESCRIPTOR_UPB_H_FILENAME
|