diff --git a/src/google/protobuf/cpp_features.pb.cc b/src/google/protobuf/cpp_features.pb.cc index fe004416c2..a102b00131 100644 --- a/src/google/protobuf/cpp_features.pb.cc +++ b/src/google/protobuf/cpp_features.pb.cc @@ -27,6 +27,7 @@ PROTOBUF_CONSTEXPR CppFeatures::CppFeatures(::_pbi::ConstantInitialized) /*decltype(_impl_._has_bits_)*/ {}, /*decltype(_impl_._cached_size_)*/ {}, /*decltype(_impl_.legacy_closed_enum_)*/ false, + /*decltype(_impl_.utf8_validation_)*/ 0, } {} struct CppFeaturesDefaultTypeInternal { PROTOBUF_CONSTEXPR CppFeaturesDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} @@ -40,8 +41,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_EXPORT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CppFeaturesDefaultTypeInternal _CppFeatures_default_instance_; } // namespace pb static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2fcpp_5ffeatures_2eproto[1]; -static constexpr const ::_pb::EnumDescriptor** - file_level_enum_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto = nullptr; +static const ::_pb::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto[1]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto = nullptr; const ::uint32_t TableStruct_google_2fprotobuf_2fcpp_5ffeatures_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( @@ -55,12 +55,14 @@ const ::uint32_t TableStruct_google_2fprotobuf_2fcpp_5ffeatures_2eproto::offsets ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::pb::CppFeatures, _impl_.legacy_closed_enum_), + PROTOBUF_FIELD_OFFSET(::pb::CppFeatures, _impl_.utf8_validation_), 0, + 1, }; static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - {0, 9, -1, sizeof(::pb::CppFeatures)}, + {0, 10, -1, sizeof(::pb::CppFeatures)}, }; static const ::_pb::Message* const file_default_instances[] = { @@ -68,11 +70,15 @@ static const ::_pb::Message* const file_default_instances[] = { }; const char descriptor_table_protodef_google_2fprotobuf_2fcpp_5ffeatures_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { "\n\"google/protobuf/cpp_features.proto\022\002pb" - "\032 google/protobuf/descriptor.proto\"D\n\013Cp" - "pFeatures\0225\n\022legacy_closed_enum\030\001 \001(\010B\031\210" - "\001\001\230\001\004\230\001\001\242\001\r\n\0042023\022\005false::\n\003cpp\022\033.google" - ".protobuf.FeatureSet\030\350\007 \001(\0132\017.pb.CppFeat" - "ures" + "\032 google/protobuf/descriptor.proto\"\373\001\n\013C" + "ppFeatures\0225\n\022legacy_closed_enum\030\001 \001(\010B\031" + "\210\001\001\230\001\004\230\001\001\242\001\r\n\0042023\022\005false\022Y\n\017utf8_valida" + "tion\030\002 \001(\0162\036.pb.CppFeatures.Utf8Validati" + "onB \210\001\001\230\001\004\230\001\001\242\001\024\n\0042023\022\014VERIFY_PARSE\"Z\n\016" + "Utf8Validation\022\033\n\027UTF8_VALIDATION_UNKNOW" + "N\020\000\022\020\n\014VERIFY_PARSE\020\001\022\017\n\013VERIFY_DLOG\020\002\022\010" + "\n\004NONE\020\003::\n\003cpp\022\033.google.protobuf.Featur" + "eSet\030\350\007 \001(\0132\017.pb.CppFeatures" }; static const ::_pbi::DescriptorTable* const descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto_deps[1] = { @@ -82,7 +88,7 @@ static ::absl::once_flag descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2ep const ::_pbi::DescriptorTable descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto = { false, false, - 204, + 388, descriptor_table_protodef_google_2fprotobuf_2fcpp_5ffeatures_2eproto, "google/protobuf/cpp_features.proto", &descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto_once, @@ -112,6 +118,34 @@ PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_google_2 return &descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto; } namespace pb { +const ::google::protobuf::EnumDescriptor* CppFeatures_Utf8Validation_descriptor() { + ::google::protobuf::internal::AssignDescriptors(&descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto); + return file_level_enum_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto[0]; +} +bool CppFeatures_Utf8Validation_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +constexpr CppFeatures_Utf8Validation CppFeatures::UTF8_VALIDATION_UNKNOWN; +constexpr CppFeatures_Utf8Validation CppFeatures::VERIFY_PARSE; +constexpr CppFeatures_Utf8Validation CppFeatures::VERIFY_DLOG; +constexpr CppFeatures_Utf8Validation CppFeatures::NONE; +constexpr CppFeatures_Utf8Validation CppFeatures::Utf8Validation_MIN; +constexpr CppFeatures_Utf8Validation CppFeatures::Utf8Validation_MAX; +constexpr int CppFeatures::Utf8Validation_ARRAYSIZE; + +#endif // (__cplusplus < 201703) && + // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) // =================================================================== class CppFeatures::_Internal { @@ -122,6 +156,9 @@ class CppFeatures::_Internal { static void set_has_legacy_closed_enum(HasBits* has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_utf8_validation(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } }; CppFeatures::CppFeatures(::google::protobuf::Arena* arena) @@ -141,6 +178,7 @@ inline void CppFeatures::SharedCtor(::_pb::Arena* arena) { decltype(_impl_._has_bits_){}, /*decltype(_impl_._cached_size_)*/ {}, decltype(_impl_.legacy_closed_enum_){false}, + decltype(_impl_.utf8_validation_){0}, }; } CppFeatures::~CppFeatures() { @@ -161,7 +199,12 @@ PROTOBUF_NOINLINE void CppFeatures::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - _impl_.legacy_closed_enum_ = false; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&_impl_.legacy_closed_enum_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.utf8_validation_) - + reinterpret_cast(&_impl_.legacy_closed_enum_)) + sizeof(_impl_.utf8_validation_)); + } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } @@ -174,20 +217,23 @@ const char* CppFeatures::_InternalParse( PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CppFeatures::_table_ = { +const ::_pbi::TcParseTable<1, 2, 1, 0, 2> CppFeatures::_table_ = { { PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_._has_bits_), 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask + 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap + 4294967292, // skipmap offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries + 2, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), &_CppFeatures_default_instance_._instance, ::_pbi::TcParser::GenericFallback, // fallback }, {{ + // optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + {::_pbi::TcParser::FastEr0S1, + {16, 1, 3, PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.utf8_validation_)}}, // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { {::_pbi::TcParser::SingularVarintNoZag1(), {8, 0, 0, PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.legacy_closed_enum_)}}, @@ -197,9 +243,12 @@ const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CppFeatures::_table_ = { // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { {PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.legacy_closed_enum_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - }}, - // no aux_entries - {{ + // optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + {PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.utf8_validation_), _Internal::kHasBitsOffset + 1, 0, + (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)}, + }}, {{ + {0, 4}, + }}, {{ }}, }; @@ -218,6 +267,13 @@ const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CppFeatures::_table_ = { 1, this->_internal_legacy_closed_enum(), target); } + // optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_utf8_validation(), target); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( @@ -235,12 +291,20 @@ const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CppFeatures::_table_ = { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 2; - } + if (cached_has_bits & 0x00000003u) { + // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + if (cached_has_bits & 0x00000001u) { + total_size += 2; + } + // optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_utf8_validation()); + } + + } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } @@ -259,8 +323,15 @@ void CppFeatures::MergeImpl(::google::protobuf::Message& to_msg, const ::google: ::uint32_t cached_has_bits = 0; (void) cached_has_bits; - if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { - _this->_internal_set_legacy_closed_enum(from._internal_legacy_closed_enum()); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.legacy_closed_enum_ = from._impl_.legacy_closed_enum_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.utf8_validation_ = from._impl_.utf8_validation_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } @@ -280,7 +351,12 @@ void CppFeatures::InternalSwap(CppFeatures* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.legacy_closed_enum_, other->_impl_.legacy_closed_enum_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.utf8_validation_) + + sizeof(CppFeatures::_impl_.utf8_validation_) + - PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.legacy_closed_enum_)>( + reinterpret_cast(&_impl_.legacy_closed_enum_), + reinterpret_cast(&other->_impl_.legacy_closed_enum_)); } ::google::protobuf::Metadata CppFeatures::GetMetadata() const { diff --git a/src/google/protobuf/cpp_features.pb.h b/src/google/protobuf/cpp_features.pb.h index 0f92660fa2..7094d32397 100644 --- a/src/google/protobuf/cpp_features.pb.h +++ b/src/google/protobuf/cpp_features.pb.h @@ -31,6 +31,7 @@ #include "google/protobuf/message.h" #include "google/protobuf/repeated_field.h" // IWYU pragma: export #include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/descriptor.pb.h" // @@protoc_insertion_point(includes) @@ -65,6 +66,36 @@ namespace protobuf { } // namespace google namespace pb { +enum CppFeatures_Utf8Validation : int { + CppFeatures_Utf8Validation_UTF8_VALIDATION_UNKNOWN = 0, + CppFeatures_Utf8Validation_VERIFY_PARSE = 1, + CppFeatures_Utf8Validation_VERIFY_DLOG = 2, + CppFeatures_Utf8Validation_NONE = 3, +}; + +PROTOBUF_EXPORT bool CppFeatures_Utf8Validation_IsValid(int value); +constexpr CppFeatures_Utf8Validation CppFeatures_Utf8Validation_Utf8Validation_MIN = static_cast(0); +constexpr CppFeatures_Utf8Validation CppFeatures_Utf8Validation_Utf8Validation_MAX = static_cast(3); +constexpr int CppFeatures_Utf8Validation_Utf8Validation_ARRAYSIZE = 3 + 1; +PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* +CppFeatures_Utf8Validation_descriptor(); +template +const std::string& CppFeatures_Utf8Validation_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to Utf8Validation_Name()."); + return CppFeatures_Utf8Validation_Name(static_cast(value)); +} +template <> +inline const std::string& CppFeatures_Utf8Validation_Name(CppFeatures_Utf8Validation value) { + return ::google::protobuf::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool CppFeatures_Utf8Validation_Parse(absl::string_view name, CppFeatures_Utf8Validation* value) { + return ::google::protobuf::internal::ParseNamedEnum( + CppFeatures_Utf8Validation_descriptor(), name, value); +} // =================================================================== @@ -196,10 +227,33 @@ class PROTOBUF_EXPORT CppFeatures final : // nested types ---------------------------------------------------- + using Utf8Validation = CppFeatures_Utf8Validation; + static constexpr Utf8Validation UTF8_VALIDATION_UNKNOWN = CppFeatures_Utf8Validation_UTF8_VALIDATION_UNKNOWN; + static constexpr Utf8Validation VERIFY_PARSE = CppFeatures_Utf8Validation_VERIFY_PARSE; + static constexpr Utf8Validation VERIFY_DLOG = CppFeatures_Utf8Validation_VERIFY_DLOG; + static constexpr Utf8Validation NONE = CppFeatures_Utf8Validation_NONE; + static inline bool Utf8Validation_IsValid(int value) { + return CppFeatures_Utf8Validation_IsValid(value); + } + static constexpr Utf8Validation Utf8Validation_MIN = CppFeatures_Utf8Validation_Utf8Validation_MIN; + static constexpr Utf8Validation Utf8Validation_MAX = CppFeatures_Utf8Validation_Utf8Validation_MAX; + static constexpr int Utf8Validation_ARRAYSIZE = CppFeatures_Utf8Validation_Utf8Validation_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* Utf8Validation_descriptor() { + return CppFeatures_Utf8Validation_descriptor(); + } + template + static inline const std::string& Utf8Validation_Name(T value) { + return CppFeatures_Utf8Validation_Name(value); + } + static inline bool Utf8Validation_Parse(absl::string_view name, Utf8Validation* value) { + return CppFeatures_Utf8Validation_Parse(name, value); + } + // accessors ------------------------------------------------------- enum : int { kLegacyClosedEnumFieldNumber = 1, + kUtf8ValidationFieldNumber = 2, }; // optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { bool has_legacy_closed_enum() const; @@ -211,6 +265,17 @@ class PROTOBUF_EXPORT CppFeatures final : bool _internal_legacy_closed_enum() const; void _internal_set_legacy_closed_enum(bool value); + public: + // optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { + bool has_utf8_validation() const; + void clear_utf8_validation() ; + ::pb::CppFeatures_Utf8Validation utf8_validation() const; + void set_utf8_validation(::pb::CppFeatures_Utf8Validation value); + + private: + ::pb::CppFeatures_Utf8Validation _internal_utf8_validation() const; + void _internal_set_utf8_validation(::pb::CppFeatures_Utf8Validation value); + public: // @@protoc_insertion_point(class_scope:pb.CppFeatures) private: @@ -218,7 +283,7 @@ class PROTOBUF_EXPORT CppFeatures final : friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, + 1, 2, 1, 0, 2> _table_; template friend class ::google::protobuf::Arena::InternalHelper; @@ -228,6 +293,7 @@ class PROTOBUF_EXPORT CppFeatures final : ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; bool legacy_closed_enum_; + int utf8_validation_; PROTOBUF_TSAN_DECLARE_MEMBER; }; union { Impl_ _impl_; }; @@ -281,6 +347,34 @@ inline void CppFeatures::_internal_set_legacy_closed_enum(bool value) { _impl_.legacy_closed_enum_ = value; } +// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = { +inline bool CppFeatures::has_utf8_validation() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline void CppFeatures::clear_utf8_validation() { + _impl_.utf8_validation_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::pb::CppFeatures_Utf8Validation CppFeatures::utf8_validation() const { + // @@protoc_insertion_point(field_get:pb.CppFeatures.utf8_validation) + return _internal_utf8_validation(); +} +inline void CppFeatures::set_utf8_validation(::pb::CppFeatures_Utf8Validation value) { + _internal_set_utf8_validation(value); + // @@protoc_insertion_point(field_set:pb.CppFeatures.utf8_validation) +} +inline ::pb::CppFeatures_Utf8Validation CppFeatures::_internal_utf8_validation() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return static_cast<::pb::CppFeatures_Utf8Validation>(_impl_.utf8_validation_); +} +inline void CppFeatures::_internal_set_utf8_validation(::pb::CppFeatures_Utf8Validation value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + assert(::pb::CppFeatures_Utf8Validation_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.utf8_validation_ = value; +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -289,6 +383,19 @@ inline void CppFeatures::_internal_set_legacy_closed_enum(bool value) { } // namespace pb +namespace google { +namespace protobuf { + +template <> +struct is_proto_enum<::pb::CppFeatures_Utf8Validation> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::pb::CppFeatures_Utf8Validation>() { + return ::pb::CppFeatures_Utf8Validation_descriptor(); +} + +} // namespace protobuf +} // namespace google + // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" diff --git a/src/google/protobuf/cpp_features.proto b/src/google/protobuf/cpp_features.proto index ee0977b842..b68192986d 100644 --- a/src/google/protobuf/cpp_features.proto +++ b/src/google/protobuf/cpp_features.proto @@ -49,4 +49,25 @@ message CppFeatures { targets = TARGET_TYPE_FILE, edition_defaults = { edition: "2023", value: "false" } ]; + + // The UTF8 validation strategy to use. See go/editions-utf8-validation for + // more information on this feature. + enum Utf8Validation { + // Invalid default, which should never be used. + UTF8_VALIDATION_UNKNOWN = 0; + // Default proto3 behavior, which verifies UTF8 validity during parse. + VERIFY_PARSE = 1; + // Default proto2 behavior, which verifies UTF8 validity during both parse + // and serialize in debug builds. On failure an error is logged, but the + // operation continues. + VERIFY_DLOG = 2; + // No UTF8 validation is done ever. + NONE = 3; + } + optional Utf8Validation utf8_validation = 2 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + edition_defaults = { edition: "2023", value: "VERIFY_PARSE" } + ]; }