google-protobuf 4.26.1-x64-mingw32 → 4.27.0.rc.2-x64-mingw32
Sign up to get free protection for your applications and to get access to all the features.
Potentially problematic release.
This version of google-protobuf might be problematic. Click here for more details.
- 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.0/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 +22 -7
- data/lib/google/2.7/protobuf_c.so +0 -0
@@ -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
|