diff --git a/cmake/libprotobuf-lite.cmake b/cmake/libprotobuf-lite.cmake index 22d5578505..344df28b5f 100644 --- a/cmake/libprotobuf-lite.cmake +++ b/cmake/libprotobuf-lite.cmake @@ -1,6 +1,5 @@ set(libprotobuf_lite_files ${protobuf_source_dir}/src/google/protobuf/arena.cc - ${protobuf_source_dir}/src/google/protobuf/arenastring.cc ${protobuf_source_dir}/src/google/protobuf/extension_set.cc ${protobuf_source_dir}/src/google/protobuf/generated_message_table_driven_lite.cc ${protobuf_source_dir}/src/google/protobuf/generated_message_util.cc diff --git a/conformance/Makefile.am b/conformance/Makefile.am index 8f30124ded..f45bfe3f99 100644 --- a/conformance/Makefile.am +++ b/conformance/Makefile.am @@ -107,6 +107,7 @@ other_language_protoc_outputs = \ google/protobuf/wrappers_pb2.py \ Conformance/ConformanceRequest.php \ Conformance/ConformanceResponse.php \ + Conformance/FailureSet.php \ Conformance/WireFormat.php \ GPBMetadata/Conformance.php \ GPBMetadata/Google/Protobuf/Any.php \ diff --git a/conformance/conformance.proto b/conformance/conformance.proto index b0dc762919..91e2ad37ba 100644 --- a/conformance/conformance.proto +++ b/conformance/conformance.proto @@ -61,7 +61,7 @@ enum WireFormat { enum TestCategory { UNSPECIFIED_TEST = 0; BINARY_TEST = 1; // Test binary wire format. - JSON_TEST = 2; // Test json wire format. + JSON_TEST = 2; // Test json wire format. // Similar to JSON_TEST. However, during parsing json, testee should ignore // unknown fields. This feature is optional. Each implementation can descide // whether to support it. See @@ -72,6 +72,10 @@ enum TestCategory { // Opensource testees just skip it. } +message FailureSet { + repeated string failure = 1; +} + // Represents a single test case's input. The testee should: // // 1. parse this proto (which should always succeed) diff --git a/conformance/conformance_cpp.cc b/conformance/conformance_cpp.cc index ce333ee7f9..a451ab0ad5 100644 --- a/conformance/conformance_cpp.cc +++ b/conformance/conformance_cpp.cc @@ -57,6 +57,35 @@ using std::string; static const char kTypeUrlPrefix[] = "type.googleapis.com"; +const char* kFailures[] = { +#if !GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + "Required.Proto2.ProtobufInput." + "PrematureEofInDelimitedDataForKnownNonRepeatedValue.MESSAGE", + "Required.Proto2.ProtobufInput." + "PrematureEofInDelimitedDataForKnownRepeatedValue.MESSAGE", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.BOOL", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.ENUM", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.INT32", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.INT64", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.SINT32", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.SINT64", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.UINT32", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.UINT64", + "Required.Proto3.ProtobufInput." + "PrematureEofInDelimitedDataForKnownNonRepeatedValue.MESSAGE", + "Required.Proto3.ProtobufInput." + "PrematureEofInDelimitedDataForKnownRepeatedValue.MESSAGE", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.BOOL", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.ENUM", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.INT32", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.INT64", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.SINT32", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.SINT64", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.UINT32", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.UINT64", +#endif +}; + static string GetTypeUrl(const Descriptor* message) { return string(kTypeUrlPrefix) + "/" + message->full_name(); } @@ -144,6 +173,12 @@ void DoTest(const ConformanceRequest& request, ConformanceResponse* response) { break; } + conformance::FailureSet failures; + if (descriptor == failures.GetDescriptor()) { + for (const char* s : kFailures) failures.add_failure(s); + test_message = &failures; + } + switch (request.requested_output_format()) { case conformance::UNSPECIFIED: GOOGLE_LOG(FATAL) << "Unspecified output format"; diff --git a/conformance/conformance_php.php b/conformance/conformance_php.php index 80860c9504..2eeaa6355d 100755 --- a/conformance/conformance_php.php +++ b/conformance/conformance_php.php @@ -3,6 +3,7 @@ require_once("Conformance/WireFormat.php"); require_once("Conformance/ConformanceResponse.php"); require_once("Conformance/ConformanceRequest.php"); +require_once("Conformance/FailureSet.php"); require_once("Conformance/JspbEncodingConfig.php"); require_once("Conformance/TestCategory.php"); require_once("Protobuf_test_messages/Proto3/ForeignMessage.php"); @@ -29,7 +30,10 @@ function doTest($request) $test_message = new \Protobuf_test_messages\Proto3\TestAllTypesProto3(); $response = new \Conformance\ConformanceResponse(); if ($request->getPayload() == "protobuf_payload") { - if ($request->getMessageType() == "protobuf_test_messages.proto3.TestAllTypesProto3") { + if ($request->getMessageType() == "conformance.FailureSet") { + $response->setProtobufPayload(""); + return $response; + } elseif ($request->getMessageType() == "protobuf_test_messages.proto3.TestAllTypesProto3") { try { $test_message->mergeFromString($request->getProtobufPayload()); } catch (Exception $e) { diff --git a/conformance/conformance_python.py b/conformance/conformance_python.py index 876642bc79..f1975e04b7 100755 --- a/conformance/conformance_python.py +++ b/conformance/conformance_python.py @@ -56,26 +56,75 @@ class ProtocolError(Exception): pass def do_test(request): + response = conformance_pb2.ConformanceResponse() + + if request.message_type == "conformance.FailureSet": + failure_set = conformance_pb2.FailureSet() + failures = [] + # TODO(gerbens): Remove, this is a hack to detect if the old vs new + # parser is used by the cpp code. Relying on a bug in the old parser. + hack_proto = test_messages_proto2_pb2.TestAllTypesProto2() + if hack_proto.ParseFromString(b"\322\002\001"): + # the string above is one of the failing conformance test strings of the + # old parser. If we succeed the c++ implementation is using the old + # parser so we add the list of failing conformance tests. + failures = [ + "Required.Proto3.ProtobufInput.PrematureEofInDelimitedDataForKnownNonRepeatedValue.MESSAGE", + "Required.Proto3.ProtobufInput.PrematureEofInDelimitedDataForKnownRepeatedValue.MESSAGE", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.BOOL", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.DOUBLE", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.ENUM", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.FIXED32", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.FIXED64", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.FLOAT", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.INT32", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.INT64", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.SFIXED32", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.SFIXED64", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.SINT32", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.SINT64", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.UINT32", + "Required.Proto3.ProtobufInput.PrematureEofInPackedField.UINT64", + "Required.Proto2.ProtobufInput.PrematureEofInDelimitedDataForKnownNonRepeatedValue.MESSAGE", + "Required.Proto2.ProtobufInput.PrematureEofInDelimitedDataForKnownRepeatedValue.MESSAGE", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.BOOL", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.DOUBLE", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.ENUM", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.FIXED32", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.FIXED64", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.FLOAT", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.INT32", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.INT64", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.SFIXED32", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.SFIXED64", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.SINT32", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.SINT64", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.UINT32", + "Required.Proto2.ProtobufInput.PrematureEofInPackedField.UINT64", + ] + for x in failures: + failure_set.failure.append(x) + response.protobuf_payload = failure_set.SerializeToString() + return response + isProto3 = (request.message_type == "protobuf_test_messages.proto3.TestAllTypesProto3") isJson = (request.WhichOneof('payload') == 'json_payload') isProto2 = (request.message_type == "protobuf_test_messages.proto2.TestAllTypesProto2") - + if (not isProto3) and (not isJson) and (not isProto2): raise ProtocolError("Protobuf request doesn't have specific payload type") - + test_message = test_messages_proto2_pb2.TestAllTypesProto2() if isProto2 else \ test_messages_proto3_pb2.TestAllTypesProto3() - response = conformance_pb2.ConformanceResponse() - try: if request.WhichOneof('payload') == 'protobuf_payload': try: test_message.ParseFromString(request.protobuf_payload) except message.DecodeError as e: response.parse_error = str(e) - return response - + return response + elif request.WhichOneof('payload') == 'json_payload': try: ignore_unknown_fields = \ @@ -97,7 +146,7 @@ def do_test(request): response.protobuf_payload = test_message.SerializeToString() elif request.requested_output_format == conformance_pb2.JSON: - try: + try: response.json_payload = json_format.MessageToJson(test_message) except Exception as e: response.serialize_error = str(e) diff --git a/conformance/conformance_test.cc b/conformance/conformance_test.cc index 68b813df4d..265a05382d 100644 --- a/conformance/conformance_test.cc +++ b/conformance/conformance_test.cc @@ -150,15 +150,6 @@ string ConformanceTestSuite::ConformanceRequestSetting:: return ""; } -void ConformanceTestSuite::SetFailureList( - const string& filename, - const std::vector& failure_list) { - failure_list_filename_ = filename; - expected_to_fail_.clear(); - std::copy(failure_list.begin(), failure_list.end(), - std::inserter(expected_to_fail_, expected_to_fail_.end())); -} - void ConformanceTestSuite::ReportSuccess(const string& test_name) { if (expected_to_fail_.erase(test_name) != 0) { StringAppendF(&output_, @@ -359,8 +350,9 @@ string ConformanceTestSuite::WireFormatToString( return ""; } -bool ConformanceTestSuite::RunSuite( - ConformanceTestRunner* runner, std::string* output) { +bool ConformanceTestSuite::RunSuite(ConformanceTestRunner* runner, + std::string* output, const string& filename, + conformance::FailureSet* failure_list) { runner_ = runner; successes_ = 0; expected_failures_ = 0; @@ -371,6 +363,18 @@ bool ConformanceTestSuite::RunSuite( output_ = "\nCONFORMANCE TEST BEGIN ====================================\n\n"; + ConformanceRequest req; + ConformanceResponse res; + req.set_message_type(failure_list->GetTypeName()); + req.set_protobuf_payload(""); + req.set_requested_output_format(conformance::WireFormat::PROTOBUF); + RunTest("FindFailures", req, &res); + GOOGLE_CHECK(failure_list->MergeFromString(res.protobuf_payload())); + failure_list_filename_ = filename; + expected_to_fail_.clear(); + for (const string& failure : failure_list->failure()) { + expected_to_fail_.insert(failure); + } RunSuiteImpl(); bool ok = true; diff --git a/conformance/conformance_test.h b/conformance/conformance_test.h index ab82bbe676..e0bc1e00d8 100644 --- a/conformance/conformance_test.h +++ b/conformance/conformance_test.h @@ -144,15 +144,6 @@ class ConformanceTestSuite { void SetVerbose(bool verbose) { verbose_ = verbose; } - // Sets the list of tests that are expected to fail when RunSuite() is called. - // RunSuite() will fail unless the set of failing tests is exactly the same - // as this list. - // - // The filename here is *only* used to create/format useful error messages for - // how to update the failure list. We do NOT read this file at all. - void SetFailureList(const std::string& filename, - const std::vector& failure_list); - // Whether to require the testee to pass RECOMMENDED tests. By default failing // a RECOMMENDED test case will not fail the entire suite but will only // generated a warning. If this flag is set to true, RECOMMENDED tests will @@ -169,9 +160,12 @@ class ConformanceTestSuite { // Test output will be stored in "output". // // Returns true if the set of failing tests was exactly the same as the - // failure list. If SetFailureList() was not called, returns true if all - // tests passed. - bool RunSuite(ConformanceTestRunner* runner, std::string* output); + // failure list. + // The filename here is *only* used to create/format useful error messages for + // how to update the failure list. We do NOT read this file at all. + bool RunSuite(ConformanceTestRunner* runner, std::string* output, + const std::string& filename, + conformance::FailureSet* failure_list); protected: // Test cases are classified into a few categories: diff --git a/conformance/conformance_test_runner.cc b/conformance/conformance_test_runner.cc index 8b44752e58..0279bb6589 100644 --- a/conformance/conformance_test_runner.cc +++ b/conformance/conformance_test_runner.cc @@ -84,7 +84,7 @@ namespace google { namespace protobuf { void ParseFailureList(const char *filename, - std::vector* failure_list) { + conformance::FailureSet *failure_list) { std::ifstream infile(filename); if (!infile.is_open()) { @@ -101,7 +101,7 @@ void ParseFailureList(const char *filename, line = line.substr(0, line.find("#")); if (!line.empty()) { - failure_list->push_back(line); + failure_list->add_failure(line); } } } @@ -178,7 +178,7 @@ int ForkPipeRunner::Run( int argc, char *argv[], ConformanceTestSuite* suite) { char *program; string failure_list_filename; - std::vector failure_list; + conformance::FailureSet failure_list; for (int arg = 1; arg < argc; ++arg) { if (strcmp(argv[arg], "--failure_list") == 0) { @@ -201,11 +201,11 @@ int ForkPipeRunner::Run( } } - suite->SetFailureList(failure_list_filename, failure_list); ForkPipeRunner runner(program); std::string output; - bool ok = suite->RunSuite(&runner, &output); + bool ok = + suite->RunSuite(&runner, &output, failure_list_filename, &failure_list); fwrite(output.c_str(), 1, output.size(), stderr); diff --git a/conformance/failure_list_cpp.txt b/conformance/failure_list_cpp.txt index 752fbb5d9b..0c01e1e40c 100644 --- a/conformance/failure_list_cpp.txt +++ b/conformance/failure_list_cpp.txt @@ -34,23 +34,3 @@ Recommended.Proto3.JsonInput.TrailingCommaInAnObject Recommended.Proto3.JsonInput.TrailingCommaInAnObjectWithNewlines Recommended.Proto3.JsonInput.TrailingCommaInAnObjectWithSpace Recommended.Proto3.JsonInput.TrailingCommaInAnObjectWithSpaceCommaSpace -Required.Proto3.ProtobufInput.PrematureEofInDelimitedDataForKnownNonRepeatedValue.MESSAGE -Required.Proto3.ProtobufInput.PrematureEofInDelimitedDataForKnownRepeatedValue.MESSAGE -Required.Proto3.ProtobufInput.PrematureEofInPackedField.BOOL -Required.Proto3.ProtobufInput.PrematureEofInPackedField.ENUM -Required.Proto3.ProtobufInput.PrematureEofInPackedField.INT32 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.INT64 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.SINT32 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.SINT64 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.UINT32 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.UINT64 -Required.Proto2.ProtobufInput.PrematureEofInDelimitedDataForKnownNonRepeatedValue.MESSAGE -Required.Proto2.ProtobufInput.PrematureEofInDelimitedDataForKnownRepeatedValue.MESSAGE -Required.Proto2.ProtobufInput.PrematureEofInPackedField.BOOL -Required.Proto2.ProtobufInput.PrematureEofInPackedField.ENUM -Required.Proto2.ProtobufInput.PrematureEofInPackedField.INT32 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.INT64 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.SINT32 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.SINT64 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.UINT32 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.UINT64 diff --git a/conformance/failure_list_python_cpp.txt b/conformance/failure_list_python_cpp.txt index a498ad1a3e..59a969d2f5 100644 --- a/conformance/failure_list_python_cpp.txt +++ b/conformance/failure_list_python_cpp.txt @@ -20,35 +20,3 @@ Required.Proto3.JsonInput.FloatFieldTooLarge Required.Proto3.JsonInput.FloatFieldTooSmall Required.Proto3.JsonInput.RepeatedFieldWrongElementTypeExpectingIntegersGotBool Required.Proto3.JsonInput.TimestampJsonInputLowercaseT -Required.Proto3.ProtobufInput.PrematureEofInDelimitedDataForKnownNonRepeatedValue.MESSAGE -Required.Proto3.ProtobufInput.PrematureEofInDelimitedDataForKnownRepeatedValue.MESSAGE -Required.Proto3.ProtobufInput.PrematureEofInPackedField.BOOL -Required.Proto3.ProtobufInput.PrematureEofInPackedField.DOUBLE -Required.Proto3.ProtobufInput.PrematureEofInPackedField.ENUM -Required.Proto3.ProtobufInput.PrematureEofInPackedField.FIXED32 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.FIXED64 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.FLOAT -Required.Proto3.ProtobufInput.PrematureEofInPackedField.INT32 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.INT64 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.SFIXED32 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.SFIXED64 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.SINT32 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.SINT64 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.UINT32 -Required.Proto3.ProtobufInput.PrematureEofInPackedField.UINT64 -Required.Proto2.ProtobufInput.PrematureEofInDelimitedDataForKnownNonRepeatedValue.MESSAGE -Required.Proto2.ProtobufInput.PrematureEofInDelimitedDataForKnownRepeatedValue.MESSAGE -Required.Proto2.ProtobufInput.PrematureEofInPackedField.BOOL -Required.Proto2.ProtobufInput.PrematureEofInPackedField.DOUBLE -Required.Proto2.ProtobufInput.PrematureEofInPackedField.ENUM -Required.Proto2.ProtobufInput.PrematureEofInPackedField.FIXED32 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.FIXED64 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.FLOAT -Required.Proto2.ProtobufInput.PrematureEofInPackedField.INT32 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.INT64 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.SFIXED32 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.SFIXED64 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.SINT32 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.SINT64 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.UINT32 -Required.Proto2.ProtobufInput.PrematureEofInPackedField.UINT64 diff --git a/csharp/src/Google.Protobuf.Conformance/Conformance.cs b/csharp/src/Google.Protobuf.Conformance/Conformance.cs index 725d2b28b3..de570f8279 100644 --- a/csharp/src/Google.Protobuf.Conformance/Conformance.cs +++ b/csharp/src/Google.Protobuf.Conformance/Conformance.cs @@ -24,28 +24,30 @@ namespace Conformance { static ConformanceReflection() { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( - "ChFjb25mb3JtYW5jZS5wcm90bxILY29uZm9ybWFuY2UirQIKEkNvbmZvcm1h", - "bmNlUmVxdWVzdBIaChBwcm90b2J1Zl9wYXlsb2FkGAEgASgMSAASFgoManNv", - "bl9wYXlsb2FkGAIgASgJSAASFgoManNwYl9wYXlsb2FkGAcgASgJSAASOAoX", - "cmVxdWVzdGVkX291dHB1dF9mb3JtYXQYAyABKA4yFy5jb25mb3JtYW5jZS5X", - "aXJlRm9ybWF0EhQKDG1lc3NhZ2VfdHlwZRgEIAEoCRIwCg10ZXN0X2NhdGVn", - "b3J5GAUgASgOMhkuY29uZm9ybWFuY2UuVGVzdENhdGVnb3J5Ej4KFWpzcGJf", - "ZW5jb2Rpbmdfb3B0aW9ucxgGIAEoCzIfLmNvbmZvcm1hbmNlLkpzcGJFbmNv", - "ZGluZ0NvbmZpZ0IJCgdwYXlsb2FkIskBChNDb25mb3JtYW5jZVJlc3BvbnNl", - "EhUKC3BhcnNlX2Vycm9yGAEgASgJSAASGQoPc2VyaWFsaXplX2Vycm9yGAYg", - "ASgJSAASFwoNcnVudGltZV9lcnJvchgCIAEoCUgAEhoKEHByb3RvYnVmX3Bh", - "eWxvYWQYAyABKAxIABIWCgxqc29uX3BheWxvYWQYBCABKAlIABIRCgdza2lw", - "cGVkGAUgASgJSAASFgoManNwYl9wYXlsb2FkGAcgASgJSABCCAoGcmVzdWx0", - "IjcKEkpzcGJFbmNvZGluZ0NvbmZpZxIhChl1c2VfanNwYl9hcnJheV9hbnlf", - "Zm9ybWF0GAEgASgIKj8KCldpcmVGb3JtYXQSDwoLVU5TUEVDSUZJRUQQABIM", - "CghQUk9UT0JVRhABEggKBEpTT04QAhIICgRKU1BCEAMqeQoMVGVzdENhdGVn", - "b3J5EhQKEFVOU1BFQ0lGSUVEX1RFU1QQABIPCgtCSU5BUllfVEVTVBABEg0K", - "CUpTT05fVEVTVBACEiQKIEpTT05fSUdOT1JFX1VOS05PV05fUEFSU0lOR19U", - "RVNUEAMSDQoJSlNQQl9URVNUEARCIQofY29tLmdvb2dsZS5wcm90b2J1Zi5j", - "b25mb3JtYW5jZWIGcHJvdG8z")); + "ChFjb25mb3JtYW5jZS5wcm90bxILY29uZm9ybWFuY2UiHQoKRmFpbHVyZVNl", + "dBIPCgdmYWlsdXJlGAEgAygJIq0CChJDb25mb3JtYW5jZVJlcXVlc3QSGgoQ", + "cHJvdG9idWZfcGF5bG9hZBgBIAEoDEgAEhYKDGpzb25fcGF5bG9hZBgCIAEo", + "CUgAEhYKDGpzcGJfcGF5bG9hZBgHIAEoCUgAEjgKF3JlcXVlc3RlZF9vdXRw", + "dXRfZm9ybWF0GAMgASgOMhcuY29uZm9ybWFuY2UuV2lyZUZvcm1hdBIUCgxt", + "ZXNzYWdlX3R5cGUYBCABKAkSMAoNdGVzdF9jYXRlZ29yeRgFIAEoDjIZLmNv", + "bmZvcm1hbmNlLlRlc3RDYXRlZ29yeRI+ChVqc3BiX2VuY29kaW5nX29wdGlv", + "bnMYBiABKAsyHy5jb25mb3JtYW5jZS5Kc3BiRW5jb2RpbmdDb25maWdCCQoH", + "cGF5bG9hZCLJAQoTQ29uZm9ybWFuY2VSZXNwb25zZRIVCgtwYXJzZV9lcnJv", + "chgBIAEoCUgAEhkKD3NlcmlhbGl6ZV9lcnJvchgGIAEoCUgAEhcKDXJ1bnRp", + "bWVfZXJyb3IYAiABKAlIABIaChBwcm90b2J1Zl9wYXlsb2FkGAMgASgMSAAS", + "FgoManNvbl9wYXlsb2FkGAQgASgJSAASEQoHc2tpcHBlZBgFIAEoCUgAEhYK", + "DGpzcGJfcGF5bG9hZBgHIAEoCUgAQggKBnJlc3VsdCI3ChJKc3BiRW5jb2Rp", + "bmdDb25maWcSIQoZdXNlX2pzcGJfYXJyYXlfYW55X2Zvcm1hdBgBIAEoCCo/", + "CgpXaXJlRm9ybWF0Eg8KC1VOU1BFQ0lGSUVEEAASDAoIUFJPVE9CVUYQARII", + "CgRKU09OEAISCAoESlNQQhADKnkKDFRlc3RDYXRlZ29yeRIUChBVTlNQRUNJ", + "RklFRF9URVNUEAASDwoLQklOQVJZX1RFU1QQARINCglKU09OX1RFU1QQAhIk", + "CiBKU09OX0lHTk9SRV9VTktOT1dOX1BBUlNJTkdfVEVTVBADEg0KCUpTUEJf", + "VEVTVBAEQiEKH2NvbS5nb29nbGUucHJvdG9idWYuY29uZm9ybWFuY2ViBnBy", + "b3RvMw==")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Conformance.WireFormat), typeof(global::Conformance.TestCategory), }, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Conformance.FailureSet), global::Conformance.FailureSet.Parser, new[]{ "Failure" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Conformance.ConformanceRequest), global::Conformance.ConformanceRequest.Parser, new[]{ "ProtobufPayload", "JsonPayload", "JspbPayload", "RequestedOutputFormat", "MessageType", "TestCategory", "JspbEncodingOptions" }, new[]{ "Payload" }, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Conformance.ConformanceResponse), global::Conformance.ConformanceResponse.Parser, new[]{ "ParseError", "SerializeError", "RuntimeError", "ProtobufPayload", "JsonPayload", "Skipped", "JspbPayload" }, new[]{ "Result" }, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Conformance.JspbEncodingConfig), global::Conformance.JspbEncodingConfig.Parser, new[]{ "UseJspbArrayAnyFormat" }, null, null, null) @@ -92,6 +94,129 @@ namespace Conformance { #endregion #region Messages + public sealed partial class FailureSet : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FailureSet()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Conformance.ConformanceReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public FailureSet() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public FailureSet(FailureSet other) : this() { + failure_ = other.failure_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public FailureSet Clone() { + return new FailureSet(this); + } + + /// Field number for the "failure" field. + public const int FailureFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_failure_codec + = pb::FieldCodec.ForString(10); + private readonly pbc::RepeatedField failure_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Failure { + get { return failure_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as FailureSet); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(FailureSet other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!failure_.Equals(other.failure_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= failure_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + failure_.WriteTo(output, _repeated_failure_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += failure_.CalculateSize(_repeated_failure_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(FailureSet other) { + if (other == null) { + return; + } + failure_.Add(other.failure_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + if (!pb::UnknownFieldSet.MergeFieldFrom(ref _unknownFields, input)) { + return; + } + break; + case 10: { + failure_.AddEntriesFrom(input, _repeated_failure_codec); + break; + } + } + } + } + + } + /// /// Represents a single test case's input. The testee should: /// @@ -107,7 +232,7 @@ namespace Conformance { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Conformance.ConformanceReflection.Descriptor.MessageTypes[0]; } + get { return global::Conformance.ConformanceReflection.Descriptor.MessageTypes[1]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -468,7 +593,7 @@ namespace Conformance { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Conformance.ConformanceReflection.Descriptor.MessageTypes[1]; } + get { return global::Conformance.ConformanceReflection.Descriptor.MessageTypes[2]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -850,7 +975,7 @@ namespace Conformance { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Conformance.ConformanceReflection.Descriptor.MessageTypes[2]; } + get { return global::Conformance.ConformanceReflection.Descriptor.MessageTypes[3]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] diff --git a/csharp/src/Google.Protobuf.Test/TestProtos/TestMessagesProto3.cs b/csharp/src/Google.Protobuf.Test/TestProtos/TestMessagesProto3.cs index 683dc41d0e..b59075bc10 100644 --- a/csharp/src/Google.Protobuf.Test/TestProtos/TestMessagesProto3.cs +++ b/csharp/src/Google.Protobuf.Test/TestProtos/TestMessagesProto3.cs @@ -29,7 +29,7 @@ namespace ProtobufTestMessages.Proto3 { "dWYvYW55LnByb3RvGh5nb29nbGUvcHJvdG9idWYvZHVyYXRpb24ucHJvdG8a", "IGdvb2dsZS9wcm90b2J1Zi9maWVsZF9tYXNrLnByb3RvGhxnb29nbGUvcHJv", "dG9idWYvc3RydWN0LnByb3RvGh9nb29nbGUvcHJvdG9idWYvdGltZXN0YW1w", - "LnByb3RvGh5nb29nbGUvcHJvdG9idWYvd3JhcHBlcnMucHJvdG8itDsKElRl", + "LnByb3RvGh5nb29nbGUvcHJvdG9idWYvd3JhcHBlcnMucHJvdG8i7TwKElRl", "c3RBbGxUeXBlc1Byb3RvMxIWCg5vcHRpb25hbF9pbnQzMhgBIAEoBRIWCg5v", "cHRpb25hbF9pbnQ2NBgCIAEoAxIXCg9vcHRpb25hbF91aW50MzIYAyABKA0S", "FwoPb3B0aW9uYWxfdWludDY0GAQgASgEEhcKD29wdGlvbmFsX3NpbnQzMhgF", @@ -46,167 +46,171 @@ namespace ProtobufTestMessages.Proto3 { "c3RlZF9lbnVtGBUgASgOMjwucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90", "bzMuVGVzdEFsbFR5cGVzUHJvdG8zLk5lc3RlZEVudW0SSQoVb3B0aW9uYWxf", "Zm9yZWlnbl9lbnVtGBYgASgOMioucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5w", - "cm90bzMuRm9yZWlnbkVudW0SIQoVb3B0aW9uYWxfc3RyaW5nX3BpZWNlGBgg", - "ASgJQgIIAhIZCg1vcHRpb25hbF9jb3JkGBkgASgJQgIIARJMChFyZWN1cnNp", - "dmVfbWVzc2FnZRgbIAEoCzIxLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJv", - "dG8zLlRlc3RBbGxUeXBlc1Byb3RvMxIWCg5yZXBlYXRlZF9pbnQzMhgfIAMo", - "BRIWCg5yZXBlYXRlZF9pbnQ2NBggIAMoAxIXCg9yZXBlYXRlZF91aW50MzIY", - "ISADKA0SFwoPcmVwZWF0ZWRfdWludDY0GCIgAygEEhcKD3JlcGVhdGVkX3Np", - "bnQzMhgjIAMoERIXCg9yZXBlYXRlZF9zaW50NjQYJCADKBISGAoQcmVwZWF0", - "ZWRfZml4ZWQzMhglIAMoBxIYChByZXBlYXRlZF9maXhlZDY0GCYgAygGEhkK", - "EXJlcGVhdGVkX3NmaXhlZDMyGCcgAygPEhkKEXJlcGVhdGVkX3NmaXhlZDY0", - "GCggAygQEhYKDnJlcGVhdGVkX2Zsb2F0GCkgAygCEhcKD3JlcGVhdGVkX2Rv", - "dWJsZRgqIAMoARIVCg1yZXBlYXRlZF9ib29sGCsgAygIEhcKD3JlcGVhdGVk", - "X3N0cmluZxgsIAMoCRIWCg5yZXBlYXRlZF9ieXRlcxgtIAMoDBJgChdyZXBl", - "YXRlZF9uZXN0ZWRfbWVzc2FnZRgwIAMoCzI/LnByb3RvYnVmX3Rlc3RfbWVz", - "c2FnZXMucHJvdG8zLlRlc3RBbGxUeXBlc1Byb3RvMy5OZXN0ZWRNZXNzYWdl", - "Ek8KGHJlcGVhdGVkX2ZvcmVpZ25fbWVzc2FnZRgxIAMoCzItLnByb3RvYnVm", - "X3Rlc3RfbWVzc2FnZXMucHJvdG8zLkZvcmVpZ25NZXNzYWdlEloKFHJlcGVh", - "dGVkX25lc3RlZF9lbnVtGDMgAygOMjwucHJvdG9idWZfdGVzdF9tZXNzYWdl", - "cy5wcm90bzMuVGVzdEFsbFR5cGVzUHJvdG8zLk5lc3RlZEVudW0SSQoVcmVw", - "ZWF0ZWRfZm9yZWlnbl9lbnVtGDQgAygOMioucHJvdG9idWZfdGVzdF9tZXNz", - "YWdlcy5wcm90bzMuRm9yZWlnbkVudW0SIQoVcmVwZWF0ZWRfc3RyaW5nX3Bp", - "ZWNlGDYgAygJQgIIAhIZCg1yZXBlYXRlZF9jb3JkGDcgAygJQgIIARJdCg9t", - "YXBfaW50MzJfaW50MzIYOCADKAsyRC5wcm90b2J1Zl90ZXN0X21lc3NhZ2Vz", - "LnByb3RvMy5UZXN0QWxsVHlwZXNQcm90bzMuTWFwSW50MzJJbnQzMkVudHJ5", - "El0KD21hcF9pbnQ2NF9pbnQ2NBg5IAMoCzJELnByb3RvYnVmX3Rlc3RfbWVz", - "c2FnZXMucHJvdG8zLlRlc3RBbGxUeXBlc1Byb3RvMy5NYXBJbnQ2NEludDY0", - "RW50cnkSYQoRbWFwX3VpbnQzMl91aW50MzIYOiADKAsyRi5wcm90b2J1Zl90", - "ZXN0X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxsVHlwZXNQcm90bzMuTWFwVWlu", - "dDMyVWludDMyRW50cnkSYQoRbWFwX3VpbnQ2NF91aW50NjQYOyADKAsyRi5w", - "cm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxsVHlwZXNQcm90", - "bzMuTWFwVWludDY0VWludDY0RW50cnkSYQoRbWFwX3NpbnQzMl9zaW50MzIY", - "PCADKAsyRi5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxs", - "VHlwZXNQcm90bzMuTWFwU2ludDMyU2ludDMyRW50cnkSYQoRbWFwX3NpbnQ2", - "NF9zaW50NjQYPSADKAsyRi5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3Rv", - "My5UZXN0QWxsVHlwZXNQcm90bzMuTWFwU2ludDY0U2ludDY0RW50cnkSZQoT", - "bWFwX2ZpeGVkMzJfZml4ZWQzMhg+IAMoCzJILnByb3RvYnVmX3Rlc3RfbWVz", - "c2FnZXMucHJvdG8zLlRlc3RBbGxUeXBlc1Byb3RvMy5NYXBGaXhlZDMyRml4", - "ZWQzMkVudHJ5EmUKE21hcF9maXhlZDY0X2ZpeGVkNjQYPyADKAsySC5wcm90", - "b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxsVHlwZXNQcm90bzMu", - "TWFwRml4ZWQ2NEZpeGVkNjRFbnRyeRJpChVtYXBfc2ZpeGVkMzJfc2ZpeGVk", - "MzIYQCADKAsySi5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMy5UZXN0", - "QWxsVHlwZXNQcm90bzMuTWFwU2ZpeGVkMzJTZml4ZWQzMkVudHJ5EmkKFW1h", - "cF9zZml4ZWQ2NF9zZml4ZWQ2NBhBIAMoCzJKLnByb3RvYnVmX3Rlc3RfbWVz", - "c2FnZXMucHJvdG8zLlRlc3RBbGxUeXBlc1Byb3RvMy5NYXBTZml4ZWQ2NFNm", - "aXhlZDY0RW50cnkSXQoPbWFwX2ludDMyX2Zsb2F0GEIgAygLMkQucHJvdG9i", + "cm90bzMuRm9yZWlnbkVudW0SXAoVb3B0aW9uYWxfYWxpYXNlZF9lbnVtGBcg", + "ASgOMj0ucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzMuVGVzdEFsbFR5", + "cGVzUHJvdG8zLkFsaWFzZWRFbnVtEiEKFW9wdGlvbmFsX3N0cmluZ19waWVj", + "ZRgYIAEoCUICCAISGQoNb3B0aW9uYWxfY29yZBgZIAEoCUICCAESTAoRcmVj", + "dXJzaXZlX21lc3NhZ2UYGyABKAsyMS5wcm90b2J1Zl90ZXN0X21lc3NhZ2Vz", + "LnByb3RvMy5UZXN0QWxsVHlwZXNQcm90bzMSFgoOcmVwZWF0ZWRfaW50MzIY", + "HyADKAUSFgoOcmVwZWF0ZWRfaW50NjQYICADKAMSFwoPcmVwZWF0ZWRfdWlu", + "dDMyGCEgAygNEhcKD3JlcGVhdGVkX3VpbnQ2NBgiIAMoBBIXCg9yZXBlYXRl", + "ZF9zaW50MzIYIyADKBESFwoPcmVwZWF0ZWRfc2ludDY0GCQgAygSEhgKEHJl", + "cGVhdGVkX2ZpeGVkMzIYJSADKAcSGAoQcmVwZWF0ZWRfZml4ZWQ2NBgmIAMo", + "BhIZChFyZXBlYXRlZF9zZml4ZWQzMhgnIAMoDxIZChFyZXBlYXRlZF9zZml4", + "ZWQ2NBgoIAMoEBIWCg5yZXBlYXRlZF9mbG9hdBgpIAMoAhIXCg9yZXBlYXRl", + "ZF9kb3VibGUYKiADKAESFQoNcmVwZWF0ZWRfYm9vbBgrIAMoCBIXCg9yZXBl", + "YXRlZF9zdHJpbmcYLCADKAkSFgoOcmVwZWF0ZWRfYnl0ZXMYLSADKAwSYAoX", + "cmVwZWF0ZWRfbmVzdGVkX21lc3NhZ2UYMCADKAsyPy5wcm90b2J1Zl90ZXN0", + "X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxsVHlwZXNQcm90bzMuTmVzdGVkTWVz", + "c2FnZRJPChhyZXBlYXRlZF9mb3JlaWduX21lc3NhZ2UYMSADKAsyLS5wcm90", + "b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMy5Gb3JlaWduTWVzc2FnZRJaChRy", + "ZXBlYXRlZF9uZXN0ZWRfZW51bRgzIAMoDjI8LnByb3RvYnVmX3Rlc3RfbWVz", + "c2FnZXMucHJvdG8zLlRlc3RBbGxUeXBlc1Byb3RvMy5OZXN0ZWRFbnVtEkkK", + "FXJlcGVhdGVkX2ZvcmVpZ25fZW51bRg0IAMoDjIqLnByb3RvYnVmX3Rlc3Rf", + "bWVzc2FnZXMucHJvdG8zLkZvcmVpZ25FbnVtEiEKFXJlcGVhdGVkX3N0cmlu", + "Z19waWVjZRg2IAMoCUICCAISGQoNcmVwZWF0ZWRfY29yZBg3IAMoCUICCAES", + "XQoPbWFwX2ludDMyX2ludDMyGDggAygLMkQucHJvdG9idWZfdGVzdF9tZXNz", + "YWdlcy5wcm90bzMuVGVzdEFsbFR5cGVzUHJvdG8zLk1hcEludDMySW50MzJF", + "bnRyeRJdCg9tYXBfaW50NjRfaW50NjQYOSADKAsyRC5wcm90b2J1Zl90ZXN0", + "X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxsVHlwZXNQcm90bzMuTWFwSW50NjRJ", + "bnQ2NEVudHJ5EmEKEW1hcF91aW50MzJfdWludDMyGDogAygLMkYucHJvdG9i", "dWZfdGVzdF9tZXNzYWdlcy5wcm90bzMuVGVzdEFsbFR5cGVzUHJvdG8zLk1h", - "cEludDMyRmxvYXRFbnRyeRJfChBtYXBfaW50MzJfZG91YmxlGEMgAygLMkUu", + "cFVpbnQzMlVpbnQzMkVudHJ5EmEKEW1hcF91aW50NjRfdWludDY0GDsgAygL", + "MkYucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzMuVGVzdEFsbFR5cGVz", + "UHJvdG8zLk1hcFVpbnQ2NFVpbnQ2NEVudHJ5EmEKEW1hcF9zaW50MzJfc2lu", + "dDMyGDwgAygLMkYucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzMuVGVz", + "dEFsbFR5cGVzUHJvdG8zLk1hcFNpbnQzMlNpbnQzMkVudHJ5EmEKEW1hcF9z", + "aW50NjRfc2ludDY0GD0gAygLMkYucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5w", + "cm90bzMuVGVzdEFsbFR5cGVzUHJvdG8zLk1hcFNpbnQ2NFNpbnQ2NEVudHJ5", + "EmUKE21hcF9maXhlZDMyX2ZpeGVkMzIYPiADKAsySC5wcm90b2J1Zl90ZXN0", + "X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxsVHlwZXNQcm90bzMuTWFwRml4ZWQz", + "MkZpeGVkMzJFbnRyeRJlChNtYXBfZml4ZWQ2NF9maXhlZDY0GD8gAygLMkgu", "cHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzMuVGVzdEFsbFR5cGVzUHJv", - "dG8zLk1hcEludDMyRG91YmxlRW50cnkSWQoNbWFwX2Jvb2xfYm9vbBhEIAMo", - "CzJCLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8zLlRlc3RBbGxUeXBl", - "c1Byb3RvMy5NYXBCb29sQm9vbEVudHJ5EmEKEW1hcF9zdHJpbmdfc3RyaW5n", - "GEUgAygLMkYucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzMuVGVzdEFs", - "bFR5cGVzUHJvdG8zLk1hcFN0cmluZ1N0cmluZ0VudHJ5El8KEG1hcF9zdHJp", - "bmdfYnl0ZXMYRiADKAsyRS5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3Rv", - "My5UZXN0QWxsVHlwZXNQcm90bzMuTWFwU3RyaW5nQnl0ZXNFbnRyeRJwChlt", - "YXBfc3RyaW5nX25lc3RlZF9tZXNzYWdlGEcgAygLMk0ucHJvdG9idWZfdGVz", - "dF9tZXNzYWdlcy5wcm90bzMuVGVzdEFsbFR5cGVzUHJvdG8zLk1hcFN0cmlu", - "Z05lc3RlZE1lc3NhZ2VFbnRyeRJyChptYXBfc3RyaW5nX2ZvcmVpZ25fbWVz", - "c2FnZRhIIAMoCzJOLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8zLlRl", - "c3RBbGxUeXBlc1Byb3RvMy5NYXBTdHJpbmdGb3JlaWduTWVzc2FnZUVudHJ5", - "EmoKFm1hcF9zdHJpbmdfbmVzdGVkX2VudW0YSSADKAsySi5wcm90b2J1Zl90", - "ZXN0X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxsVHlwZXNQcm90bzMuTWFwU3Ry", - "aW5nTmVzdGVkRW51bUVudHJ5EmwKF21hcF9zdHJpbmdfZm9yZWlnbl9lbnVt", - "GEogAygLMksucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzMuVGVzdEFs", - "bFR5cGVzUHJvdG8zLk1hcFN0cmluZ0ZvcmVpZ25FbnVtRW50cnkSFgoMb25l", - "b2ZfdWludDMyGG8gASgNSAASXwoUb25lb2ZfbmVzdGVkX21lc3NhZ2UYcCAB", - "KAsyPy5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxsVHlw", - "ZXNQcm90bzMuTmVzdGVkTWVzc2FnZUgAEhYKDG9uZW9mX3N0cmluZxhxIAEo", - "CUgAEhUKC29uZW9mX2J5dGVzGHIgASgMSAASFAoKb25lb2ZfYm9vbBhzIAEo", - "CEgAEhYKDG9uZW9mX3VpbnQ2NBh0IAEoBEgAEhUKC29uZW9mX2Zsb2F0GHUg", - "ASgCSAASFgoMb25lb2ZfZG91YmxlGHYgASgBSAASUgoKb25lb2ZfZW51bRh3", - "IAEoDjI8LnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8zLlRlc3RBbGxU", - "eXBlc1Byb3RvMy5OZXN0ZWRFbnVtSAASOgoVb3B0aW9uYWxfYm9vbF93cmFw", - "cGVyGMkBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5Cb29sVmFsdWUSPAoWb3B0", - "aW9uYWxfaW50MzJfd3JhcHBlchjKASABKAsyGy5nb29nbGUucHJvdG9idWYu", - "SW50MzJWYWx1ZRI8ChZvcHRpb25hbF9pbnQ2NF93cmFwcGVyGMsBIAEoCzIb", - "Lmdvb2dsZS5wcm90b2J1Zi5JbnQ2NFZhbHVlEj4KF29wdGlvbmFsX3VpbnQz", - "Ml93cmFwcGVyGMwBIAEoCzIcLmdvb2dsZS5wcm90b2J1Zi5VSW50MzJWYWx1", - "ZRI+ChdvcHRpb25hbF91aW50NjRfd3JhcHBlchjNASABKAsyHC5nb29nbGUu", - "cHJvdG9idWYuVUludDY0VmFsdWUSPAoWb3B0aW9uYWxfZmxvYXRfd3JhcHBl", - "chjOASABKAsyGy5nb29nbGUucHJvdG9idWYuRmxvYXRWYWx1ZRI+ChdvcHRp", - "b25hbF9kb3VibGVfd3JhcHBlchjPASABKAsyHC5nb29nbGUucHJvdG9idWYu", - "RG91YmxlVmFsdWUSPgoXb3B0aW9uYWxfc3RyaW5nX3dyYXBwZXIY0AEgASgL", - "MhwuZ29vZ2xlLnByb3RvYnVmLlN0cmluZ1ZhbHVlEjwKFm9wdGlvbmFsX2J5", - "dGVzX3dyYXBwZXIY0QEgASgLMhsuZ29vZ2xlLnByb3RvYnVmLkJ5dGVzVmFs", - "dWUSOgoVcmVwZWF0ZWRfYm9vbF93cmFwcGVyGNMBIAMoCzIaLmdvb2dsZS5w", - "cm90b2J1Zi5Cb29sVmFsdWUSPAoWcmVwZWF0ZWRfaW50MzJfd3JhcHBlchjU", - "ASADKAsyGy5nb29nbGUucHJvdG9idWYuSW50MzJWYWx1ZRI8ChZyZXBlYXRl", - "ZF9pbnQ2NF93cmFwcGVyGNUBIAMoCzIbLmdvb2dsZS5wcm90b2J1Zi5JbnQ2", - "NFZhbHVlEj4KF3JlcGVhdGVkX3VpbnQzMl93cmFwcGVyGNYBIAMoCzIcLmdv", - "b2dsZS5wcm90b2J1Zi5VSW50MzJWYWx1ZRI+ChdyZXBlYXRlZF91aW50NjRf", - "d3JhcHBlchjXASADKAsyHC5nb29nbGUucHJvdG9idWYuVUludDY0VmFsdWUS", - "PAoWcmVwZWF0ZWRfZmxvYXRfd3JhcHBlchjYASADKAsyGy5nb29nbGUucHJv", - "dG9idWYuRmxvYXRWYWx1ZRI+ChdyZXBlYXRlZF9kb3VibGVfd3JhcHBlchjZ", - "ASADKAsyHC5nb29nbGUucHJvdG9idWYuRG91YmxlVmFsdWUSPgoXcmVwZWF0", - "ZWRfc3RyaW5nX3dyYXBwZXIY2gEgAygLMhwuZ29vZ2xlLnByb3RvYnVmLlN0", - "cmluZ1ZhbHVlEjwKFnJlcGVhdGVkX2J5dGVzX3dyYXBwZXIY2wEgAygLMhsu", - "Z29vZ2xlLnByb3RvYnVmLkJ5dGVzVmFsdWUSNQoRb3B0aW9uYWxfZHVyYXRp", - "b24YrQIgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uEjcKEm9wdGlv", - "bmFsX3RpbWVzdGFtcBiuAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0", - "YW1wEjgKE29wdGlvbmFsX2ZpZWxkX21hc2sYrwIgASgLMhouZ29vZ2xlLnBy", - "b3RvYnVmLkZpZWxkTWFzaxIxCg9vcHRpb25hbF9zdHJ1Y3QYsAIgASgLMhcu", - "Z29vZ2xlLnByb3RvYnVmLlN0cnVjdBIrCgxvcHRpb25hbF9hbnkYsQIgASgL", - "MhQuZ29vZ2xlLnByb3RvYnVmLkFueRIvCg5vcHRpb25hbF92YWx1ZRiyAiAB", - "KAsyFi5nb29nbGUucHJvdG9idWYuVmFsdWUSNQoRcmVwZWF0ZWRfZHVyYXRp", - "b24YtwIgAygLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uEjcKEnJlcGVh", - "dGVkX3RpbWVzdGFtcBi4AiADKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0", - "YW1wEjcKEnJlcGVhdGVkX2ZpZWxkbWFzaxi5AiADKAsyGi5nb29nbGUucHJv", - "dG9idWYuRmllbGRNYXNrEjEKD3JlcGVhdGVkX3N0cnVjdBjEAiADKAsyFy5n", - "b29nbGUucHJvdG9idWYuU3RydWN0EisKDHJlcGVhdGVkX2FueRi7AiADKAsy", - "FC5nb29nbGUucHJvdG9idWYuQW55Ei8KDnJlcGVhdGVkX3ZhbHVlGLwCIAMo", - "CzIWLmdvb2dsZS5wcm90b2J1Zi5WYWx1ZRITCgpmaWVsZG5hbWUxGJEDIAEo", - "BRIUCgtmaWVsZF9uYW1lMhiSAyABKAUSFQoMX2ZpZWxkX25hbWUzGJMDIAEo", - "BRIWCg1maWVsZF9fbmFtZTRfGJQDIAEoBRIUCgtmaWVsZDBuYW1lNRiVAyAB", - "KAUSFgoNZmllbGRfMF9uYW1lNhiWAyABKAUSEwoKZmllbGROYW1lNxiXAyAB", - "KAUSEwoKRmllbGROYW1lOBiYAyABKAUSFAoLZmllbGRfTmFtZTkYmQMgASgF", - "EhUKDEZpZWxkX05hbWUxMBiaAyABKAUSFQoMRklFTERfTkFNRTExGJsDIAEo", - "BRIVCgxGSUVMRF9uYW1lMTIYnAMgASgFEhcKDl9fZmllbGRfbmFtZTEzGJ0D", - "IAEoBRIXCg5fX0ZpZWxkX25hbWUxNBieAyABKAUSFgoNZmllbGRfX25hbWUx", - "NRifAyABKAUSFgoNZmllbGRfX05hbWUxNhigAyABKAUSFwoOZmllbGRfbmFt", - "ZTE3X18YoQMgASgFEhcKDkZpZWxkX25hbWUxOF9fGKIDIAEoBRpiCg1OZXN0", - "ZWRNZXNzYWdlEgkKAWEYASABKAUSRgoLY29yZWN1cnNpdmUYAiABKAsyMS5w", - "cm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxsVHlwZXNQcm90", - "bzMaNAoSTWFwSW50MzJJbnQzMkVudHJ5EgsKA2tleRgBIAEoBRINCgV2YWx1", - "ZRgCIAEoBToCOAEaNAoSTWFwSW50NjRJbnQ2NEVudHJ5EgsKA2tleRgBIAEo", - "AxINCgV2YWx1ZRgCIAEoAzoCOAEaNgoUTWFwVWludDMyVWludDMyRW50cnkS", - "CwoDa2V5GAEgASgNEg0KBXZhbHVlGAIgASgNOgI4ARo2ChRNYXBVaW50NjRV", - "aW50NjRFbnRyeRILCgNrZXkYASABKAQSDQoFdmFsdWUYAiABKAQ6AjgBGjYK", - "FE1hcFNpbnQzMlNpbnQzMkVudHJ5EgsKA2tleRgBIAEoERINCgV2YWx1ZRgC", - "IAEoEToCOAEaNgoUTWFwU2ludDY0U2ludDY0RW50cnkSCwoDa2V5GAEgASgS", - "Eg0KBXZhbHVlGAIgASgSOgI4ARo4ChZNYXBGaXhlZDMyRml4ZWQzMkVudHJ5", - "EgsKA2tleRgBIAEoBxINCgV2YWx1ZRgCIAEoBzoCOAEaOAoWTWFwRml4ZWQ2", - "NEZpeGVkNjRFbnRyeRILCgNrZXkYASABKAYSDQoFdmFsdWUYAiABKAY6AjgB", - "GjoKGE1hcFNmaXhlZDMyU2ZpeGVkMzJFbnRyeRILCgNrZXkYASABKA8SDQoF", - "dmFsdWUYAiABKA86AjgBGjoKGE1hcFNmaXhlZDY0U2ZpeGVkNjRFbnRyeRIL", - "CgNrZXkYASABKBASDQoFdmFsdWUYAiABKBA6AjgBGjQKEk1hcEludDMyRmxv", - "YXRFbnRyeRILCgNrZXkYASABKAUSDQoFdmFsdWUYAiABKAI6AjgBGjUKE01h", - "cEludDMyRG91YmxlRW50cnkSCwoDa2V5GAEgASgFEg0KBXZhbHVlGAIgASgB", - "OgI4ARoyChBNYXBCb29sQm9vbEVudHJ5EgsKA2tleRgBIAEoCBINCgV2YWx1", - "ZRgCIAEoCDoCOAEaNgoUTWFwU3RyaW5nU3RyaW5nRW50cnkSCwoDa2V5GAEg", - "ASgJEg0KBXZhbHVlGAIgASgJOgI4ARo1ChNNYXBTdHJpbmdCeXRlc0VudHJ5", - "EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoDDoCOAEafgobTWFwU3RyaW5n", - "TmVzdGVkTWVzc2FnZUVudHJ5EgsKA2tleRgBIAEoCRJOCgV2YWx1ZRgCIAEo", - "CzI/LnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8zLlRlc3RBbGxUeXBl", - "c1Byb3RvMy5OZXN0ZWRNZXNzYWdlOgI4ARptChxNYXBTdHJpbmdGb3JlaWdu", - "TWVzc2FnZUVudHJ5EgsKA2tleRgBIAEoCRI8CgV2YWx1ZRgCIAEoCzItLnBy", - "b3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8zLkZvcmVpZ25NZXNzYWdlOgI4", - "ARp4ChhNYXBTdHJpbmdOZXN0ZWRFbnVtRW50cnkSCwoDa2V5GAEgASgJEksK", - "BXZhbHVlGAIgASgOMjwucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzMu", - "VGVzdEFsbFR5cGVzUHJvdG8zLk5lc3RlZEVudW06AjgBGmcKGU1hcFN0cmlu", - "Z0ZvcmVpZ25FbnVtRW50cnkSCwoDa2V5GAEgASgJEjkKBXZhbHVlGAIgASgO", - "MioucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzMuRm9yZWlnbkVudW06", - "AjgBIjkKCk5lc3RlZEVudW0SBwoDRk9PEAASBwoDQkFSEAESBwoDQkFaEAIS", - "EAoDTkVHEP///////////wFCDQoLb25lb2ZfZmllbGRKBgj1AxD/AyIbCg5G", - "b3JlaWduTWVzc2FnZRIJCgFjGAEgASgFKkAKC0ZvcmVpZ25FbnVtEg8KC0ZP", - "UkVJR05fRk9PEAASDwoLRk9SRUlHTl9CQVIQARIPCgtGT1JFSUdOX0JBWhAC", - "QjgKKGNvbS5nb29nbGUucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzNI", - "AfgBAaICBlByb3RvM2IGcHJvdG8z")); + "dG8zLk1hcEZpeGVkNjRGaXhlZDY0RW50cnkSaQoVbWFwX3NmaXhlZDMyX3Nm", + "aXhlZDMyGEAgAygLMkoucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzMu", + "VGVzdEFsbFR5cGVzUHJvdG8zLk1hcFNmaXhlZDMyU2ZpeGVkMzJFbnRyeRJp", + "ChVtYXBfc2ZpeGVkNjRfc2ZpeGVkNjQYQSADKAsySi5wcm90b2J1Zl90ZXN0", + "X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxsVHlwZXNQcm90bzMuTWFwU2ZpeGVk", + "NjRTZml4ZWQ2NEVudHJ5El0KD21hcF9pbnQzMl9mbG9hdBhCIAMoCzJELnBy", + "b3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8zLlRlc3RBbGxUeXBlc1Byb3Rv", + "My5NYXBJbnQzMkZsb2F0RW50cnkSXwoQbWFwX2ludDMyX2RvdWJsZRhDIAMo", + "CzJFLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8zLlRlc3RBbGxUeXBl", + "c1Byb3RvMy5NYXBJbnQzMkRvdWJsZUVudHJ5ElkKDW1hcF9ib29sX2Jvb2wY", + "RCADKAsyQi5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxs", + "VHlwZXNQcm90bzMuTWFwQm9vbEJvb2xFbnRyeRJhChFtYXBfc3RyaW5nX3N0", + "cmluZxhFIAMoCzJGLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8zLlRl", + "c3RBbGxUeXBlc1Byb3RvMy5NYXBTdHJpbmdTdHJpbmdFbnRyeRJfChBtYXBf", + "c3RyaW5nX2J5dGVzGEYgAygLMkUucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5w", + "cm90bzMuVGVzdEFsbFR5cGVzUHJvdG8zLk1hcFN0cmluZ0J5dGVzRW50cnkS", + "cAoZbWFwX3N0cmluZ19uZXN0ZWRfbWVzc2FnZRhHIAMoCzJNLnByb3RvYnVm", + "X3Rlc3RfbWVzc2FnZXMucHJvdG8zLlRlc3RBbGxUeXBlc1Byb3RvMy5NYXBT", + "dHJpbmdOZXN0ZWRNZXNzYWdlRW50cnkScgoabWFwX3N0cmluZ19mb3JlaWdu", + "X21lc3NhZ2UYSCADKAsyTi5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3Rv", + "My5UZXN0QWxsVHlwZXNQcm90bzMuTWFwU3RyaW5nRm9yZWlnbk1lc3NhZ2VF", + "bnRyeRJqChZtYXBfc3RyaW5nX25lc3RlZF9lbnVtGEkgAygLMkoucHJvdG9i", + "dWZfdGVzdF9tZXNzYWdlcy5wcm90bzMuVGVzdEFsbFR5cGVzUHJvdG8zLk1h", + "cFN0cmluZ05lc3RlZEVudW1FbnRyeRJsChdtYXBfc3RyaW5nX2ZvcmVpZ25f", + "ZW51bRhKIAMoCzJLLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8zLlRl", + "c3RBbGxUeXBlc1Byb3RvMy5NYXBTdHJpbmdGb3JlaWduRW51bUVudHJ5EhYK", + "DG9uZW9mX3VpbnQzMhhvIAEoDUgAEl8KFG9uZW9mX25lc3RlZF9tZXNzYWdl", + "GHAgASgLMj8ucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzMuVGVzdEFs", + "bFR5cGVzUHJvdG8zLk5lc3RlZE1lc3NhZ2VIABIWCgxvbmVvZl9zdHJpbmcY", + "cSABKAlIABIVCgtvbmVvZl9ieXRlcxhyIAEoDEgAEhQKCm9uZW9mX2Jvb2wY", + "cyABKAhIABIWCgxvbmVvZl91aW50NjQYdCABKARIABIVCgtvbmVvZl9mbG9h", + "dBh1IAEoAkgAEhYKDG9uZW9mX2RvdWJsZRh2IAEoAUgAElIKCm9uZW9mX2Vu", + "dW0YdyABKA4yPC5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMy5UZXN0", + "QWxsVHlwZXNQcm90bzMuTmVzdGVkRW51bUgAEjoKFW9wdGlvbmFsX2Jvb2xf", + "d3JhcHBlchjJASABKAsyGi5nb29nbGUucHJvdG9idWYuQm9vbFZhbHVlEjwK", + "Fm9wdGlvbmFsX2ludDMyX3dyYXBwZXIYygEgASgLMhsuZ29vZ2xlLnByb3Rv", + "YnVmLkludDMyVmFsdWUSPAoWb3B0aW9uYWxfaW50NjRfd3JhcHBlchjLASAB", + "KAsyGy5nb29nbGUucHJvdG9idWYuSW50NjRWYWx1ZRI+ChdvcHRpb25hbF91", + "aW50MzJfd3JhcHBlchjMASABKAsyHC5nb29nbGUucHJvdG9idWYuVUludDMy", + "VmFsdWUSPgoXb3B0aW9uYWxfdWludDY0X3dyYXBwZXIYzQEgASgLMhwuZ29v", + "Z2xlLnByb3RvYnVmLlVJbnQ2NFZhbHVlEjwKFm9wdGlvbmFsX2Zsb2F0X3dy", + "YXBwZXIYzgEgASgLMhsuZ29vZ2xlLnByb3RvYnVmLkZsb2F0VmFsdWUSPgoX", + "b3B0aW9uYWxfZG91YmxlX3dyYXBwZXIYzwEgASgLMhwuZ29vZ2xlLnByb3Rv", + "YnVmLkRvdWJsZVZhbHVlEj4KF29wdGlvbmFsX3N0cmluZ193cmFwcGVyGNAB", + "IAEoCzIcLmdvb2dsZS5wcm90b2J1Zi5TdHJpbmdWYWx1ZRI8ChZvcHRpb25h", + "bF9ieXRlc193cmFwcGVyGNEBIAEoCzIbLmdvb2dsZS5wcm90b2J1Zi5CeXRl", + "c1ZhbHVlEjoKFXJlcGVhdGVkX2Jvb2xfd3JhcHBlchjTASADKAsyGi5nb29n", + "bGUucHJvdG9idWYuQm9vbFZhbHVlEjwKFnJlcGVhdGVkX2ludDMyX3dyYXBw", + "ZXIY1AEgAygLMhsuZ29vZ2xlLnByb3RvYnVmLkludDMyVmFsdWUSPAoWcmVw", + "ZWF0ZWRfaW50NjRfd3JhcHBlchjVASADKAsyGy5nb29nbGUucHJvdG9idWYu", + "SW50NjRWYWx1ZRI+ChdyZXBlYXRlZF91aW50MzJfd3JhcHBlchjWASADKAsy", + "HC5nb29nbGUucHJvdG9idWYuVUludDMyVmFsdWUSPgoXcmVwZWF0ZWRfdWlu", + "dDY0X3dyYXBwZXIY1wEgAygLMhwuZ29vZ2xlLnByb3RvYnVmLlVJbnQ2NFZh", + "bHVlEjwKFnJlcGVhdGVkX2Zsb2F0X3dyYXBwZXIY2AEgAygLMhsuZ29vZ2xl", + "LnByb3RvYnVmLkZsb2F0VmFsdWUSPgoXcmVwZWF0ZWRfZG91YmxlX3dyYXBw", + "ZXIY2QEgAygLMhwuZ29vZ2xlLnByb3RvYnVmLkRvdWJsZVZhbHVlEj4KF3Jl", + "cGVhdGVkX3N0cmluZ193cmFwcGVyGNoBIAMoCzIcLmdvb2dsZS5wcm90b2J1", + "Zi5TdHJpbmdWYWx1ZRI8ChZyZXBlYXRlZF9ieXRlc193cmFwcGVyGNsBIAMo", + "CzIbLmdvb2dsZS5wcm90b2J1Zi5CeXRlc1ZhbHVlEjUKEW9wdGlvbmFsX2R1", + "cmF0aW9uGK0CIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbhI3ChJv", + "cHRpb25hbF90aW1lc3RhbXAYrgIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRp", + "bWVzdGFtcBI4ChNvcHRpb25hbF9maWVsZF9tYXNrGK8CIAEoCzIaLmdvb2ds", + "ZS5wcm90b2J1Zi5GaWVsZE1hc2sSMQoPb3B0aW9uYWxfc3RydWN0GLACIAEo", + "CzIXLmdvb2dsZS5wcm90b2J1Zi5TdHJ1Y3QSKwoMb3B0aW9uYWxfYW55GLEC", + "IAEoCzIULmdvb2dsZS5wcm90b2J1Zi5BbnkSLwoOb3B0aW9uYWxfdmFsdWUY", + "sgIgASgLMhYuZ29vZ2xlLnByb3RvYnVmLlZhbHVlEjUKEXJlcGVhdGVkX2R1", + "cmF0aW9uGLcCIAMoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbhI3ChJy", + "ZXBlYXRlZF90aW1lc3RhbXAYuAIgAygLMhouZ29vZ2xlLnByb3RvYnVmLlRp", + "bWVzdGFtcBI3ChJyZXBlYXRlZF9maWVsZG1hc2sYuQIgAygLMhouZ29vZ2xl", + "LnByb3RvYnVmLkZpZWxkTWFzaxIxCg9yZXBlYXRlZF9zdHJ1Y3QYxAIgAygL", + "MhcuZ29vZ2xlLnByb3RvYnVmLlN0cnVjdBIrCgxyZXBlYXRlZF9hbnkYuwIg", + "AygLMhQuZ29vZ2xlLnByb3RvYnVmLkFueRIvCg5yZXBlYXRlZF92YWx1ZRi8", + "AiADKAsyFi5nb29nbGUucHJvdG9idWYuVmFsdWUSEwoKZmllbGRuYW1lMRiR", + "AyABKAUSFAoLZmllbGRfbmFtZTIYkgMgASgFEhUKDF9maWVsZF9uYW1lMxiT", + "AyABKAUSFgoNZmllbGRfX25hbWU0XxiUAyABKAUSFAoLZmllbGQwbmFtZTUY", + "lQMgASgFEhYKDWZpZWxkXzBfbmFtZTYYlgMgASgFEhMKCmZpZWxkTmFtZTcY", + "lwMgASgFEhMKCkZpZWxkTmFtZTgYmAMgASgFEhQKC2ZpZWxkX05hbWU5GJkD", + "IAEoBRIVCgxGaWVsZF9OYW1lMTAYmgMgASgFEhUKDEZJRUxEX05BTUUxMRib", + "AyABKAUSFQoMRklFTERfbmFtZTEyGJwDIAEoBRIXCg5fX2ZpZWxkX25hbWUx", + "MxidAyABKAUSFwoOX19GaWVsZF9uYW1lMTQYngMgASgFEhYKDWZpZWxkX19u", + "YW1lMTUYnwMgASgFEhYKDWZpZWxkX19OYW1lMTYYoAMgASgFEhcKDmZpZWxk", + "X25hbWUxN19fGKEDIAEoBRIXCg5GaWVsZF9uYW1lMThfXxiiAyABKAUaYgoN", + "TmVzdGVkTWVzc2FnZRIJCgFhGAEgASgFEkYKC2NvcmVjdXJzaXZlGAIgASgL", + "MjEucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzMuVGVzdEFsbFR5cGVz", + "UHJvdG8zGjQKEk1hcEludDMySW50MzJFbnRyeRILCgNrZXkYASABKAUSDQoF", + "dmFsdWUYAiABKAU6AjgBGjQKEk1hcEludDY0SW50NjRFbnRyeRILCgNrZXkY", + "ASABKAMSDQoFdmFsdWUYAiABKAM6AjgBGjYKFE1hcFVpbnQzMlVpbnQzMkVu", + "dHJ5EgsKA2tleRgBIAEoDRINCgV2YWx1ZRgCIAEoDToCOAEaNgoUTWFwVWlu", + "dDY0VWludDY0RW50cnkSCwoDa2V5GAEgASgEEg0KBXZhbHVlGAIgASgEOgI4", + "ARo2ChRNYXBTaW50MzJTaW50MzJFbnRyeRILCgNrZXkYASABKBESDQoFdmFs", + "dWUYAiABKBE6AjgBGjYKFE1hcFNpbnQ2NFNpbnQ2NEVudHJ5EgsKA2tleRgB", + "IAEoEhINCgV2YWx1ZRgCIAEoEjoCOAEaOAoWTWFwRml4ZWQzMkZpeGVkMzJF", + "bnRyeRILCgNrZXkYASABKAcSDQoFdmFsdWUYAiABKAc6AjgBGjgKFk1hcEZp", + "eGVkNjRGaXhlZDY0RW50cnkSCwoDa2V5GAEgASgGEg0KBXZhbHVlGAIgASgG", + "OgI4ARo6ChhNYXBTZml4ZWQzMlNmaXhlZDMyRW50cnkSCwoDa2V5GAEgASgP", + "Eg0KBXZhbHVlGAIgASgPOgI4ARo6ChhNYXBTZml4ZWQ2NFNmaXhlZDY0RW50", + "cnkSCwoDa2V5GAEgASgQEg0KBXZhbHVlGAIgASgQOgI4ARo0ChJNYXBJbnQz", + "MkZsb2F0RW50cnkSCwoDa2V5GAEgASgFEg0KBXZhbHVlGAIgASgCOgI4ARo1", + "ChNNYXBJbnQzMkRvdWJsZUVudHJ5EgsKA2tleRgBIAEoBRINCgV2YWx1ZRgC", + "IAEoAToCOAEaMgoQTWFwQm9vbEJvb2xFbnRyeRILCgNrZXkYASABKAgSDQoF", + "dmFsdWUYAiABKAg6AjgBGjYKFE1hcFN0cmluZ1N0cmluZ0VudHJ5EgsKA2tl", + "eRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEaNQoTTWFwU3RyaW5nQnl0ZXNF", + "bnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAw6AjgBGn4KG01hcFN0", + "cmluZ05lc3RlZE1lc3NhZ2VFbnRyeRILCgNrZXkYASABKAkSTgoFdmFsdWUY", + "AiABKAsyPy5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMy5UZXN0QWxs", + "VHlwZXNQcm90bzMuTmVzdGVkTWVzc2FnZToCOAEabQocTWFwU3RyaW5nRm9y", + "ZWlnbk1lc3NhZ2VFbnRyeRILCgNrZXkYASABKAkSPAoFdmFsdWUYAiABKAsy", + "LS5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMy5Gb3JlaWduTWVzc2Fn", + "ZToCOAEaeAoYTWFwU3RyaW5nTmVzdGVkRW51bUVudHJ5EgsKA2tleRgBIAEo", + "CRJLCgV2YWx1ZRgCIAEoDjI8LnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJv", + "dG8zLlRlc3RBbGxUeXBlc1Byb3RvMy5OZXN0ZWRFbnVtOgI4ARpnChlNYXBT", + "dHJpbmdGb3JlaWduRW51bUVudHJ5EgsKA2tleRgBIAEoCRI5CgV2YWx1ZRgC", + "IAEoDjIqLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8zLkZvcmVpZ25F", + "bnVtOgI4ASI5CgpOZXN0ZWRFbnVtEgcKA0ZPTxAAEgcKA0JBUhABEgcKA0JB", + "WhACEhAKA05FRxD///////////8BIlkKC0FsaWFzZWRFbnVtEg0KCUFMSUFT", + "X0ZPTxAAEg0KCUFMSUFTX0JBUhABEg0KCUFMSUFTX0JBWhACEgcKA1FVWBAC", + "EgcKA3F1eBACEgcKA2JBehACGgIQAUINCgtvbmVvZl9maWVsZEoGCPUDEP8D", + "IhsKDkZvcmVpZ25NZXNzYWdlEgkKAWMYASABKAUqQAoLRm9yZWlnbkVudW0S", + "DwoLRk9SRUlHTl9GT08QABIPCgtGT1JFSUdOX0JBUhABEg8KC0ZPUkVJR05f", + "QkFaEAJCOAooY29tLmdvb2dsZS5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnBy", + "b3RvM0gB+AEBogIGUHJvdG8zYgZwcm90bzM=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.AnyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.DurationReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::ProtobufTestMessages.Proto3.ForeignEnum), }, new pbr::GeneratedClrTypeInfo[] { - new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto3.TestAllTypesProto3), global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Parser, new[]{ "OptionalInt32", "OptionalInt64", "OptionalUint32", "OptionalUint64", "OptionalSint32", "OptionalSint64", "OptionalFixed32", "OptionalFixed64", "OptionalSfixed32", "OptionalSfixed64", "OptionalFloat", "OptionalDouble", "OptionalBool", "OptionalString", "OptionalBytes", "OptionalNestedMessage", "OptionalForeignMessage", "OptionalNestedEnum", "OptionalForeignEnum", "OptionalStringPiece", "OptionalCord", "RecursiveMessage", "RepeatedInt32", "RepeatedInt64", "RepeatedUint32", "RepeatedUint64", "RepeatedSint32", "RepeatedSint64", "RepeatedFixed32", "RepeatedFixed64", "RepeatedSfixed32", "RepeatedSfixed64", "RepeatedFloat", "RepeatedDouble", "RepeatedBool", "RepeatedString", "RepeatedBytes", "RepeatedNestedMessage", "RepeatedForeignMessage", "RepeatedNestedEnum", "RepeatedForeignEnum", "RepeatedStringPiece", "RepeatedCord", "MapInt32Int32", "MapInt64Int64", "MapUint32Uint32", "MapUint64Uint64", "MapSint32Sint32", "MapSint64Sint64", "MapFixed32Fixed32", "MapFixed64Fixed64", "MapSfixed32Sfixed32", "MapSfixed64Sfixed64", "MapInt32Float", "MapInt32Double", "MapBoolBool", "MapStringString", "MapStringBytes", "MapStringNestedMessage", "MapStringForeignMessage", "MapStringNestedEnum", "MapStringForeignEnum", "OneofUint32", "OneofNestedMessage", "OneofString", "OneofBytes", "OneofBool", "OneofUint64", "OneofFloat", "OneofDouble", "OneofEnum", "OptionalBoolWrapper", "OptionalInt32Wrapper", "OptionalInt64Wrapper", "OptionalUint32Wrapper", "OptionalUint64Wrapper", "OptionalFloatWrapper", "OptionalDoubleWrapper", "OptionalStringWrapper", "OptionalBytesWrapper", "RepeatedBoolWrapper", "RepeatedInt32Wrapper", "RepeatedInt64Wrapper", "RepeatedUint32Wrapper", "RepeatedUint64Wrapper", "RepeatedFloatWrapper", "RepeatedDoubleWrapper", "RepeatedStringWrapper", "RepeatedBytesWrapper", "OptionalDuration", "OptionalTimestamp", "OptionalFieldMask", "OptionalStruct", "OptionalAny", "OptionalValue", "RepeatedDuration", "RepeatedTimestamp", "RepeatedFieldmask", "RepeatedStruct", "RepeatedAny", "RepeatedValue", "Fieldname1", "FieldName2", "FieldName3", "FieldName4", "Field0Name5", "Field0Name6", "FieldName7", "FieldName8", "FieldName9", "FieldName10", "FIELDNAME11", "FIELDName12", "FieldName13", "FieldName14", "FieldName15", "FieldName16", "FieldName17", "FieldName18" }, new[]{ "OneofField" }, new[]{ typeof(global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.NestedEnum) }, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.NestedMessage), global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.NestedMessage.Parser, new[]{ "A", "Corecursive" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto3.TestAllTypesProto3), global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Parser, new[]{ "OptionalInt32", "OptionalInt64", "OptionalUint32", "OptionalUint64", "OptionalSint32", "OptionalSint64", "OptionalFixed32", "OptionalFixed64", "OptionalSfixed32", "OptionalSfixed64", "OptionalFloat", "OptionalDouble", "OptionalBool", "OptionalString", "OptionalBytes", "OptionalNestedMessage", "OptionalForeignMessage", "OptionalNestedEnum", "OptionalForeignEnum", "OptionalAliasedEnum", "OptionalStringPiece", "OptionalCord", "RecursiveMessage", "RepeatedInt32", "RepeatedInt64", "RepeatedUint32", "RepeatedUint64", "RepeatedSint32", "RepeatedSint64", "RepeatedFixed32", "RepeatedFixed64", "RepeatedSfixed32", "RepeatedSfixed64", "RepeatedFloat", "RepeatedDouble", "RepeatedBool", "RepeatedString", "RepeatedBytes", "RepeatedNestedMessage", "RepeatedForeignMessage", "RepeatedNestedEnum", "RepeatedForeignEnum", "RepeatedStringPiece", "RepeatedCord", "MapInt32Int32", "MapInt64Int64", "MapUint32Uint32", "MapUint64Uint64", "MapSint32Sint32", "MapSint64Sint64", "MapFixed32Fixed32", "MapFixed64Fixed64", "MapSfixed32Sfixed32", "MapSfixed64Sfixed64", "MapInt32Float", "MapInt32Double", "MapBoolBool", "MapStringString", "MapStringBytes", "MapStringNestedMessage", "MapStringForeignMessage", "MapStringNestedEnum", "MapStringForeignEnum", "OneofUint32", "OneofNestedMessage", "OneofString", "OneofBytes", "OneofBool", "OneofUint64", "OneofFloat", "OneofDouble", "OneofEnum", "OptionalBoolWrapper", "OptionalInt32Wrapper", "OptionalInt64Wrapper", "OptionalUint32Wrapper", "OptionalUint64Wrapper", "OptionalFloatWrapper", "OptionalDoubleWrapper", "OptionalStringWrapper", "OptionalBytesWrapper", "RepeatedBoolWrapper", "RepeatedInt32Wrapper", "RepeatedInt64Wrapper", "RepeatedUint32Wrapper", "RepeatedUint64Wrapper", "RepeatedFloatWrapper", "RepeatedDoubleWrapper", "RepeatedStringWrapper", "RepeatedBytesWrapper", "OptionalDuration", "OptionalTimestamp", "OptionalFieldMask", "OptionalStruct", "OptionalAny", "OptionalValue", "RepeatedDuration", "RepeatedTimestamp", "RepeatedFieldmask", "RepeatedStruct", "RepeatedAny", "RepeatedValue", "Fieldname1", "FieldName2", "FieldName3", "FieldName4", "Field0Name5", "Field0Name6", "FieldName7", "FieldName8", "FieldName9", "FieldName10", "FIELDNAME11", "FIELDName12", "FieldName13", "FieldName14", "FieldName15", "FieldName16", "FieldName17", "FieldName18" }, new[]{ "OneofField" }, new[]{ typeof(global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.NestedEnum), typeof(global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.AliasedEnum) }, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.NestedMessage), global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.NestedMessage.Parser, new[]{ "A", "Corecursive" }, null, null, null), null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, }), new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto3.ForeignMessage), global::ProtobufTestMessages.Proto3.ForeignMessage.Parser, new[]{ "C" }, null, null, null) })); @@ -277,6 +281,7 @@ namespace ProtobufTestMessages.Proto3 { optionalForeignMessage_ = other.optionalForeignMessage_ != null ? other.optionalForeignMessage_.Clone() : null; optionalNestedEnum_ = other.optionalNestedEnum_; optionalForeignEnum_ = other.optionalForeignEnum_; + optionalAliasedEnum_ = other.optionalAliasedEnum_; optionalStringPiece_ = other.optionalStringPiece_; optionalCord_ = other.optionalCord_; recursiveMessage_ = other.recursiveMessage_ != null ? other.recursiveMessage_.Clone() : null; @@ -618,6 +623,17 @@ namespace ProtobufTestMessages.Proto3 { } } + /// Field number for the "optional_aliased_enum" field. + public const int OptionalAliasedEnumFieldNumber = 23; + private global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.AliasedEnum optionalAliasedEnum_ = 0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.AliasedEnum OptionalAliasedEnum { + get { return optionalAliasedEnum_; } + set { + optionalAliasedEnum_ = value; + } + } + /// Field number for the "optional_string_piece" field. public const int OptionalStringPieceFieldNumber = 24; private string optionalStringPiece_ = ""; @@ -1752,6 +1768,7 @@ namespace ProtobufTestMessages.Proto3 { if (!object.Equals(OptionalForeignMessage, other.OptionalForeignMessage)) return false; if (OptionalNestedEnum != other.OptionalNestedEnum) return false; if (OptionalForeignEnum != other.OptionalForeignEnum) return false; + if (OptionalAliasedEnum != other.OptionalAliasedEnum) return false; if (OptionalStringPiece != other.OptionalStringPiece) return false; if (OptionalCord != other.OptionalCord) return false; if (!object.Equals(RecursiveMessage, other.RecursiveMessage)) return false; @@ -1878,6 +1895,7 @@ namespace ProtobufTestMessages.Proto3 { if (optionalForeignMessage_ != null) hash ^= OptionalForeignMessage.GetHashCode(); if (OptionalNestedEnum != 0) hash ^= OptionalNestedEnum.GetHashCode(); if (OptionalForeignEnum != 0) hash ^= OptionalForeignEnum.GetHashCode(); + if (OptionalAliasedEnum != 0) hash ^= OptionalAliasedEnum.GetHashCode(); if (OptionalStringPiece.Length != 0) hash ^= OptionalStringPiece.GetHashCode(); if (OptionalCord.Length != 0) hash ^= OptionalCord.GetHashCode(); if (recursiveMessage_ != null) hash ^= RecursiveMessage.GetHashCode(); @@ -2068,6 +2086,10 @@ namespace ProtobufTestMessages.Proto3 { output.WriteRawTag(176, 1); output.WriteEnum((int) OptionalForeignEnum); } + if (OptionalAliasedEnum != 0) { + output.WriteRawTag(184, 1); + output.WriteEnum((int) OptionalAliasedEnum); + } if (OptionalStringPiece.Length != 0) { output.WriteRawTag(194, 1); output.WriteString(OptionalStringPiece); @@ -2359,6 +2381,9 @@ namespace ProtobufTestMessages.Proto3 { if (OptionalForeignEnum != 0) { size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) OptionalForeignEnum); } + if (OptionalAliasedEnum != 0) { + size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) OptionalAliasedEnum); + } if (OptionalStringPiece.Length != 0) { size += 2 + pb::CodedOutputStream.ComputeStringSize(OptionalStringPiece); } @@ -2623,6 +2648,9 @@ namespace ProtobufTestMessages.Proto3 { if (other.OptionalForeignEnum != 0) { OptionalForeignEnum = other.OptionalForeignEnum; } + if (other.OptionalAliasedEnum != 0) { + OptionalAliasedEnum = other.OptionalAliasedEnum; + } if (other.OptionalStringPiece.Length != 0) { OptionalStringPiece = other.OptionalStringPiece; } @@ -2953,6 +2981,10 @@ namespace ProtobufTestMessages.Proto3 { OptionalForeignEnum = (global::ProtobufTestMessages.Proto3.ForeignEnum) input.ReadEnum(); break; } + case 184: { + OptionalAliasedEnum = (global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.AliasedEnum) input.ReadEnum(); + break; + } case 194: { OptionalStringPiece = input.ReadString(); break; @@ -3440,6 +3472,15 @@ namespace ProtobufTestMessages.Proto3 { [pbr::OriginalName("NEG")] Neg = -1, } + public enum AliasedEnum { + [pbr::OriginalName("ALIAS_FOO")] AliasFoo = 0, + [pbr::OriginalName("ALIAS_BAR")] AliasBar = 1, + [pbr::OriginalName("ALIAS_BAZ")] AliasBaz = 2, + [pbr::OriginalName("QUX", PreferredAlias = false)] Qux = 2, + [pbr::OriginalName("qux", PreferredAlias = false)] Qux_ = 2, + [pbr::OriginalName("bAz", PreferredAlias = false)] BAz = 2, + } + public sealed partial class NestedMessage : pb::IMessage { private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NestedMessage()); private pb::UnknownFieldSet _unknownFields; diff --git a/csharp/src/Google.Protobuf.Test/testprotos.pb b/csharp/src/Google.Protobuf.Test/testprotos.pb index cf1a89a8ca..23d9272756 100644 Binary files a/csharp/src/Google.Protobuf.Test/testprotos.pb and b/csharp/src/Google.Protobuf.Test/testprotos.pb differ diff --git a/java/core/src/main/java/com/google/protobuf/BooleanArrayList.java b/java/core/src/main/java/com/google/protobuf/BooleanArrayList.java index 3c168e6929..2a41cf1ef0 100644 --- a/java/core/src/main/java/com/google/protobuf/BooleanArrayList.java +++ b/java/core/src/main/java/com/google/protobuf/BooleanArrayList.java @@ -45,7 +45,8 @@ import java.util.RandomAccess; final class BooleanArrayList extends AbstractProtobufList implements BooleanList, RandomAccess, PrimitiveNonBoxingCollection { - private static final BooleanArrayList EMPTY_LIST = new BooleanArrayList(); + private static final BooleanArrayList EMPTY_LIST = new BooleanArrayList(new boolean[0], 0); + static { EMPTY_LIST.makeImmutable(); } diff --git a/java/core/src/main/java/com/google/protobuf/CodedInputStream.java b/java/core/src/main/java/com/google/protobuf/CodedInputStream.java index 161a1b64fa..ec48796164 100644 --- a/java/core/src/main/java/com/google/protobuf/CodedInputStream.java +++ b/java/core/src/main/java/com/google/protobuf/CodedInputStream.java @@ -377,7 +377,7 @@ public abstract class CodedInputStream { /** * Set the maximum message recursion depth. In order to prevent malicious messages from causing * stack overflows, {@code CodedInputStream} limits how deeply messages may be nested. The default - * limit is 64. + * limit is 100. * * @return the old limit. */ diff --git a/java/core/src/main/java/com/google/protobuf/DoubleArrayList.java b/java/core/src/main/java/com/google/protobuf/DoubleArrayList.java index d0fa9b7e68..d4f63d6b91 100644 --- a/java/core/src/main/java/com/google/protobuf/DoubleArrayList.java +++ b/java/core/src/main/java/com/google/protobuf/DoubleArrayList.java @@ -45,7 +45,8 @@ import java.util.RandomAccess; final class DoubleArrayList extends AbstractProtobufList implements DoubleList, RandomAccess, PrimitiveNonBoxingCollection { - private static final DoubleArrayList EMPTY_LIST = new DoubleArrayList(); + private static final DoubleArrayList EMPTY_LIST = new DoubleArrayList(new double[0], 0); + static { EMPTY_LIST.makeImmutable(); } diff --git a/java/core/src/main/java/com/google/protobuf/FloatArrayList.java b/java/core/src/main/java/com/google/protobuf/FloatArrayList.java index 62330c3aa0..ac20de865b 100644 --- a/java/core/src/main/java/com/google/protobuf/FloatArrayList.java +++ b/java/core/src/main/java/com/google/protobuf/FloatArrayList.java @@ -45,7 +45,8 @@ import java.util.RandomAccess; final class FloatArrayList extends AbstractProtobufList implements FloatList, RandomAccess, PrimitiveNonBoxingCollection { - private static final FloatArrayList EMPTY_LIST = new FloatArrayList(); + private static final FloatArrayList EMPTY_LIST = new FloatArrayList(new float[0], 0); + static { EMPTY_LIST.makeImmutable(); } diff --git a/java/core/src/main/java/com/google/protobuf/IntArrayList.java b/java/core/src/main/java/com/google/protobuf/IntArrayList.java index ad128b59d8..54a378b001 100644 --- a/java/core/src/main/java/com/google/protobuf/IntArrayList.java +++ b/java/core/src/main/java/com/google/protobuf/IntArrayList.java @@ -45,7 +45,8 @@ import java.util.RandomAccess; final class IntArrayList extends AbstractProtobufList implements IntList, RandomAccess, PrimitiveNonBoxingCollection { - private static final IntArrayList EMPTY_LIST = new IntArrayList(); + private static final IntArrayList EMPTY_LIST = new IntArrayList(new int[0], 0); + static { EMPTY_LIST.makeImmutable(); } diff --git a/java/core/src/main/java/com/google/protobuf/LongArrayList.java b/java/core/src/main/java/com/google/protobuf/LongArrayList.java index 99f7fdbc5c..1a0943cee0 100644 --- a/java/core/src/main/java/com/google/protobuf/LongArrayList.java +++ b/java/core/src/main/java/com/google/protobuf/LongArrayList.java @@ -45,7 +45,8 @@ import java.util.RandomAccess; final class LongArrayList extends AbstractProtobufList implements LongList, RandomAccess, PrimitiveNonBoxingCollection { - private static final LongArrayList EMPTY_LIST = new LongArrayList(); + private static final LongArrayList EMPTY_LIST = new LongArrayList(new long[0], 0); + static { EMPTY_LIST.makeImmutable(); } diff --git a/java/core/src/main/java/com/google/protobuf/ProtobufArrayList.java b/java/core/src/main/java/com/google/protobuf/ProtobufArrayList.java index 9834161382..f9a9c85942 100644 --- a/java/core/src/main/java/com/google/protobuf/ProtobufArrayList.java +++ b/java/core/src/main/java/com/google/protobuf/ProtobufArrayList.java @@ -37,7 +37,8 @@ import java.util.List; /** Implements {@link ProtobufList} for non-primitive and {@link String} types. */ final class ProtobufArrayList extends AbstractProtobufList { - private static final ProtobufArrayList EMPTY_LIST = new ProtobufArrayList(); + private static final ProtobufArrayList EMPTY_LIST = + new ProtobufArrayList(new ArrayList(0)); static { EMPTY_LIST.makeImmutable(); diff --git a/js/binary/proto_test.js b/js/binary/proto_test.js index 161821068f..ae31c8d1ce 100644 --- a/js/binary/proto_test.js +++ b/js/binary/proto_test.js @@ -661,4 +661,5 @@ describe('protoBinaryTest', function() { checkAllFields(msg, msg2); }); + }); diff --git a/js/message.js b/js/message.js index 17b562e16e..1ca9fac0f5 100644 --- a/js/message.js +++ b/js/message.js @@ -41,6 +41,8 @@ goog.provide('jspb.Message'); goog.require('goog.array'); goog.require('goog.asserts'); goog.require('goog.crypt.base64'); +goog.require('jspb.BinaryConstants'); +goog.require('jspb.BinaryReader'); goog.require('jspb.Map'); // Not needed in compilation units that have no protos with xids. @@ -622,10 +624,7 @@ jspb.Message.serializeBinaryExtensions = function(proto, writer, extensions, * Reads an extension field from the given reader and, if a valid extension, * sets the extension value. * @param {!jspb.Message} msg A jspb proto. - * @param {{ - * skipField:function(this:jspb.BinaryReader), - * getFieldNumber:function(this:jspb.BinaryReader):number - * }} reader + * @param {!jspb.BinaryReader} reader * @param {!Object} extensions The extensions object. * @param {function(this:jspb.Message,!jspb.ExtensionFieldInfo)} getExtensionFn * @param {function(this:jspb.Message,!jspb.ExtensionFieldInfo, ?)} setExtensionFn diff --git a/js/testbinary.proto b/js/testbinary.proto index ed5bdfc68f..ee4d2dfac4 100644 --- a/js/testbinary.proto +++ b/js/testbinary.proto @@ -242,3 +242,4 @@ enum MapValueEnum { message MapValueMessage { optional int32 foo = 1; } + diff --git a/python/google/protobuf/message.py b/python/google/protobuf/message.py index 2f89857c85..8854c86529 100755 --- a/python/google/protobuf/message.py +++ b/python/google/protobuf/message.py @@ -172,6 +172,9 @@ class Message(object): we *do* stop because of an END_GROUP tag, the number of bytes returned does not include the bytes for the END_GROUP tag information. + + Raises: + message.DecodeError if the input cannot be parsed. """ raise NotImplementedError diff --git a/src/Makefile.am b/src/Makefile.am index 16cbe0ce31..13a5a149a8 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -201,7 +201,6 @@ libprotobuf_lite_la_SOURCES = \ google/protobuf/stubs/time.cc \ google/protobuf/stubs/time.h \ google/protobuf/arena.cc \ - google/protobuf/arenastring.cc \ google/protobuf/extension_set.cc \ google/protobuf/generated_message_util.cc \ google/protobuf/generated_message_table_driven_lite.h \ diff --git a/src/google/protobuf/any.pb.cc b/src/google/protobuf/any.pb.cc index 1c95380d27..4e994a8075 100644 --- a/src/google/protobuf/any.pb.cc +++ b/src/google/protobuf/any.pb.cc @@ -195,7 +195,7 @@ void Any::Clear() { const char* Any::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -207,7 +207,7 @@ const char* Any::_InternalParse(const char* begin, const char* end, void* object // string type_url = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Any.type_url"); auto str = msg->mutable_type_url(); @@ -226,7 +226,7 @@ const char* Any::_InternalParse(const char* begin, const char* end, void* object // bytes value = 2; case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); auto str = msg->mutable_value(); if (size > end - ptr + ::google::protobuf::internal::ParseContext::kSlopBytes) { diff --git a/src/google/protobuf/any.pb.h b/src/google/protobuf/any.pb.h index ba93762273..5858b1208c 100644 --- a/src/google/protobuf/any.pb.h +++ b/src/google/protobuf/any.pb.h @@ -62,7 +62,8 @@ namespace protobuf { // =================================================================== -class PROTOBUF_EXPORT Any : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Any) */ { +class PROTOBUF_EXPORT Any final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Any) */ { public: Any(); virtual ~Any(); diff --git a/src/google/protobuf/api.pb.cc b/src/google/protobuf/api.pb.cc index 2a5c466efb..63695f78a0 100644 --- a/src/google/protobuf/api.pb.cc +++ b/src/google/protobuf/api.pb.cc @@ -301,7 +301,7 @@ void Api::Clear() { const char* Api::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -313,7 +313,7 @@ const char* Api::_InternalParse(const char* begin, const char* end, void* object // string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Api.name"); auto str = msg->mutable_name(); @@ -333,7 +333,7 @@ const char* Api::_InternalParse(const char* begin, const char* end, void* object case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Method::_InternalParse; object = msg->add_methods(); @@ -351,7 +351,7 @@ const char* Api::_InternalParse(const char* begin, const char* end, void* object case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Option::_InternalParse; object = msg->add_options(); @@ -368,7 +368,7 @@ const char* Api::_InternalParse(const char* begin, const char* end, void* object // string version = 4; case 4: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Api.version"); auto str = msg->mutable_version(); @@ -387,7 +387,7 @@ const char* Api::_InternalParse(const char* begin, const char* end, void* object // .google.protobuf.SourceContext source_context = 5; case 5: { if (static_cast<::google::protobuf::uint8>(tag) != 42) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::SourceContext::_InternalParse; object = msg->mutable_source_context(); @@ -403,7 +403,7 @@ const char* Api::_InternalParse(const char* begin, const char* end, void* object case 6: { if (static_cast<::google::protobuf::uint8>(tag) != 50) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Mixin::_InternalParse; object = msg->add_mixins(); @@ -972,7 +972,7 @@ void Method::Clear() { const char* Method::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -984,7 +984,7 @@ const char* Method::_InternalParse(const char* begin, const char* end, void* obj // string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Method.name"); auto str = msg->mutable_name(); @@ -1003,7 +1003,7 @@ const char* Method::_InternalParse(const char* begin, const char* end, void* obj // string request_type_url = 2; case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Method.request_type_url"); auto str = msg->mutable_request_type_url(); @@ -1032,7 +1032,7 @@ const char* Method::_InternalParse(const char* begin, const char* end, void* obj // string response_type_url = 4; case 4: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Method.response_type_url"); auto str = msg->mutable_response_type_url(); @@ -1062,7 +1062,7 @@ const char* Method::_InternalParse(const char* begin, const char* end, void* obj case 6: { if (static_cast<::google::protobuf::uint8>(tag) != 50) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Option::_InternalParse; object = msg->add_options(); @@ -1601,7 +1601,7 @@ void Mixin::Clear() { const char* Mixin::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -1613,7 +1613,7 @@ const char* Mixin::_InternalParse(const char* begin, const char* end, void* obje // string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Mixin.name"); auto str = msg->mutable_name(); @@ -1632,7 +1632,7 @@ const char* Mixin::_InternalParse(const char* begin, const char* end, void* obje // string root = 2; case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Mixin.root"); auto str = msg->mutable_root(); diff --git a/src/google/protobuf/api.pb.h b/src/google/protobuf/api.pb.h index 518c6be844..11e819610e 100644 --- a/src/google/protobuf/api.pb.h +++ b/src/google/protobuf/api.pb.h @@ -71,7 +71,8 @@ namespace protobuf { // =================================================================== -class PROTOBUF_EXPORT Api : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Api) */ { +class PROTOBUF_EXPORT Api final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Api) */ { public: Api(); virtual ~Api(); @@ -261,7 +262,8 @@ class PROTOBUF_EXPORT Api : public ::google::protobuf::Message /* @@protoc_inser }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT Method : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Method) */ { +class PROTOBUF_EXPORT Method final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Method) */ { public: Method(); virtual ~Method(); @@ -444,7 +446,8 @@ class PROTOBUF_EXPORT Method : public ::google::protobuf::Message /* @@protoc_in }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT Mixin : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Mixin) */ { +class PROTOBUF_EXPORT Mixin final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Mixin) */ { public: Mixin(); virtual ~Mixin(); diff --git a/src/google/protobuf/compiler/cpp/cpp_helpers.cc b/src/google/protobuf/compiler/cpp/cpp_helpers.cc index dc540cfa27..8e35a0e0a9 100644 --- a/src/google/protobuf/compiler/cpp/cpp_helpers.cc +++ b/src/google/protobuf/compiler/cpp/cpp_helpers.cc @@ -1323,7 +1323,7 @@ class ParseLoopGenerator { "end, void* object,\n" " ::$proto_ns$::internal::ParseContext* ctx) {\n" " auto msg = static_cast<$classname$*>(object);\n" - " $uint32$ size; (void)size;\n" + " $int32$ size; (void)size;\n" " int depth; (void)depth;\n" " $uint32$ tag;\n" " ::$proto_ns$::internal::ParseFunc parser_till_end; " @@ -1548,7 +1548,7 @@ class ParseLoopGenerator { void GenerateLengthDelim(const FieldDescriptor* field) { format_( - "ptr = ::$proto_ns$::io::Parse32(ptr, &size);\n" + "ptr = ::$proto_ns$::io::ReadSize(ptr, &size);\n" "$GOOGLE_PROTOBUF$_PARSER_ASSERT(ptr);\n"); if (!IsProto1(field->file(), options_) && field->is_packable()) { if (!HasPreservingUnknownEnumSemantics(field->file()) && diff --git a/src/google/protobuf/compiler/cpp/cpp_message.cc b/src/google/protobuf/compiler/cpp/cpp_message.cc index a729282080..10aef2db16 100644 --- a/src/google/protobuf/compiler/cpp/cpp_message.cc +++ b/src/google/protobuf/compiler/cpp/cpp_message.cc @@ -244,6 +244,12 @@ bool HasPrivateHasMethod(const FieldDescriptor* field) { // TODO(ckennelly): Cull these exclusions if/when these protos do not have // their methods overriden by subclasses. +bool ShouldMarkClassAsFinal(const Descriptor* descriptor, + const Options& options) { + const string name = ClassName(descriptor, true); + return HasPrefixString(name, "::google::protobuf"); +} + bool ShouldMarkClearAsFinal(const Descriptor* descriptor, const Options& options) { static std::set exclusions{ @@ -926,6 +932,9 @@ void MessageGenerator::GenerateFieldAccessorDefinitions(io::Printer* printer) { void MessageGenerator::GenerateClassDefinition(io::Printer* printer) { Formatter format(printer, variables_); + format.Set("class_final", + ShouldMarkClassAsFinal(descriptor_, options_) ? "final": ""); + if (IsMapEntryMessage(descriptor_)) { std::map vars; CollectMapInfo(options_, descriptor_, &vars); @@ -967,9 +976,9 @@ void MessageGenerator::GenerateClassDefinition(io::Printer* printer) { } format( - "class $dllexport_decl $${1$$classname$$}$ : public $superclass$ " - "/* @@protoc_insertion_point(class_definition:$full_name$) */ " - "{\n", + "class $dllexport_decl $${1$$classname$$}$$ class_final$ :\n" + " public $superclass$ /* @@protoc_insertion_point(" + "class_definition:$full_name$) */ {\n", descriptor_); format(" public:\n"); format.Indent(); diff --git a/src/google/protobuf/compiler/js/js_generator.cc b/src/google/protobuf/compiler/js/js_generator.cc index 06383936de..c85cb7993b 100644 --- a/src/google/protobuf/compiler/js/js_generator.cc +++ b/src/google/protobuf/compiler/js/js_generator.cc @@ -3064,38 +3064,42 @@ void Generator::GenerateClassDeserializeBinary(const GeneratorOptions& options, " * @return {!$class$}\n" " */\n" "$class$.deserializeBinaryFromReader = function(msg, reader) {\n" - " while (reader.nextField()) {\n" - " if (reader.isEndGroup()) {\n" - " break;\n" - " }\n" - " var field = reader.getFieldNumber();\n" - " switch (field) {\n", + " while (reader.nextField()) {\n", "class", GetMessagePath(options, desc)); + printer->Print( + " if (reader.isEndGroup()) {\n" + " break;\n" + " }\n" + " var field = reader.getFieldNumber();\n" + " switch (field) {\n"); - for (int i = 0; i < desc->field_count(); i++) { - if (!IgnoreField(desc->field(i))) { - GenerateClassDeserializeBinaryField(options, printer, desc->field(i)); + + for (int i = 0; i < desc->field_count(); i++) { + if (!IgnoreField(desc->field(i))) { + GenerateClassDeserializeBinaryField(options, printer, desc->field(i)); + } } - } - printer->Print( - " default:\n"); - if (IsExtendable(desc)) { printer->Print( - " jspb.Message.readBinaryExtension(msg, reader, $extobj$Binary,\n" - " $class$.prototype.getExtension,\n" - " $class$.prototype.setExtension);\n" - " break;\n", - "extobj", JSExtensionsObjectName(options, desc->file(), desc), - "class", GetMessagePath(options, desc)); - } else { - printer->Print( - " reader.skipField();\n" - " break;\n"); - } + " default:\n"); + if (IsExtendable(desc)) { + printer->Print( + " jspb.Message.readBinaryExtension(msg, reader,\n" + " $extobj$Binary,\n" + " $class$.prototype.getExtension,\n" + " $class$.prototype.setExtension);\n" + " break;\n" + " }\n", + "extobj", JSExtensionsObjectName(options, desc->file(), desc), + "class", GetMessagePath(options, desc)); + } else { + printer->Print( + " reader.skipField();\n" + " break;\n" + " }\n"); + } printer->Print( - " }\n" " }\n" " return msg;\n" "};\n" diff --git a/src/google/protobuf/compiler/plugin.pb.cc b/src/google/protobuf/compiler/plugin.pb.cc index 9b34152949..857eec7eae 100644 --- a/src/google/protobuf/compiler/plugin.pb.cc +++ b/src/google/protobuf/compiler/plugin.pb.cc @@ -314,7 +314,7 @@ void Version::Clear() { const char* Version::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -356,7 +356,7 @@ const char* Version::_InternalParse(const char* begin, const char* end, void* ob // optional string suffix = 4; case 4: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.compiler.Version.suffix"); auto str = msg->mutable_suffix(); @@ -793,7 +793,7 @@ void CodeGeneratorRequest::Clear() { const char* CodeGeneratorRequest::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -806,7 +806,7 @@ const char* CodeGeneratorRequest::_InternalParse(const char* begin, const char* case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.compiler.CodeGeneratorRequest.file_to_generate"); auto str = msg->add_file_to_generate(); @@ -827,7 +827,7 @@ const char* CodeGeneratorRequest::_InternalParse(const char* begin, const char* // optional string parameter = 2; case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.compiler.CodeGeneratorRequest.parameter"); auto str = msg->mutable_parameter(); @@ -846,7 +846,7 @@ const char* CodeGeneratorRequest::_InternalParse(const char* begin, const char* // optional .google.protobuf.compiler.Version compiler_version = 3; case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::compiler::Version::_InternalParse; object = msg->mutable_compiler_version(); @@ -862,7 +862,7 @@ const char* CodeGeneratorRequest::_InternalParse(const char* begin, const char* case 15: { if (static_cast<::google::protobuf::uint8>(tag) != 122) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::FileDescriptorProto::_InternalParse; object = msg->add_proto_file(); @@ -1312,7 +1312,7 @@ void CodeGeneratorResponse_File::Clear() { const char* CodeGeneratorResponse_File::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -1324,7 +1324,7 @@ const char* CodeGeneratorResponse_File::_InternalParse(const char* begin, const // optional string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.compiler.CodeGeneratorResponse.File.name"); auto str = msg->mutable_name(); @@ -1343,7 +1343,7 @@ const char* CodeGeneratorResponse_File::_InternalParse(const char* begin, const // optional string insertion_point = 2; case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point"); auto str = msg->mutable_insertion_point(); @@ -1362,7 +1362,7 @@ const char* CodeGeneratorResponse_File::_InternalParse(const char* begin, const // optional string content = 15; case 15: { if (static_cast<::google::protobuf::uint8>(tag) != 122) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.compiler.CodeGeneratorResponse.File.content"); auto str = msg->mutable_content(); @@ -1764,7 +1764,7 @@ void CodeGeneratorResponse::Clear() { const char* CodeGeneratorResponse::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -1776,7 +1776,7 @@ const char* CodeGeneratorResponse::_InternalParse(const char* begin, const char* // optional string error = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.compiler.CodeGeneratorResponse.error"); auto str = msg->mutable_error(); @@ -1796,7 +1796,7 @@ const char* CodeGeneratorResponse::_InternalParse(const char* begin, const char* case 15: { if (static_cast<::google::protobuf::uint8>(tag) != 122) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::compiler::CodeGeneratorResponse_File::_InternalParse; object = msg->add_file(); diff --git a/src/google/protobuf/compiler/plugin.pb.h b/src/google/protobuf/compiler/plugin.pb.h index a8e4479fb4..c84da10231 100644 --- a/src/google/protobuf/compiler/plugin.pb.h +++ b/src/google/protobuf/compiler/plugin.pb.h @@ -83,7 +83,8 @@ namespace compiler { // =================================================================== -class PROTOC_EXPORT Version : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.Version) */ { +class PROTOC_EXPORT Version final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.Version) */ { public: Version(); virtual ~Version(); @@ -235,7 +236,8 @@ class PROTOC_EXPORT Version : public ::google::protobuf::Message /* @@protoc_ins }; // ------------------------------------------------------------------- -class PROTOC_EXPORT CodeGeneratorRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorRequest) */ { +class PROTOC_EXPORT CodeGeneratorRequest final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorRequest) */ { public: CodeGeneratorRequest(); virtual ~CodeGeneratorRequest(); @@ -409,7 +411,8 @@ class PROTOC_EXPORT CodeGeneratorRequest : public ::google::protobuf::Message /* }; // ------------------------------------------------------------------- -class PROTOC_EXPORT CodeGeneratorResponse_File : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse.File) */ { +class PROTOC_EXPORT CodeGeneratorResponse_File final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse.File) */ { public: CodeGeneratorResponse_File(); virtual ~CodeGeneratorResponse_File(); @@ -569,7 +572,8 @@ class PROTOC_EXPORT CodeGeneratorResponse_File : public ::google::protobuf::Mess }; // ------------------------------------------------------------------- -class PROTOC_EXPORT CodeGeneratorResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse) */ { +class PROTOC_EXPORT CodeGeneratorResponse final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse) */ { public: CodeGeneratorResponse(); virtual ~CodeGeneratorResponse(); diff --git a/src/google/protobuf/descriptor.pb.cc b/src/google/protobuf/descriptor.pb.cc index 198bcca7f0..bba219b48d 100644 --- a/src/google/protobuf/descriptor.pb.cc +++ b/src/google/protobuf/descriptor.pb.cc @@ -1468,7 +1468,7 @@ void FileDescriptorSet::Clear() { const char* FileDescriptorSet::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -1481,7 +1481,7 @@ const char* FileDescriptorSet::_InternalParse(const char* begin, const char* end case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::FileDescriptorProto::_InternalParse; object = msg->add_file(); @@ -1924,7 +1924,7 @@ void FileDescriptorProto::Clear() { const char* FileDescriptorProto::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -1936,7 +1936,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e // optional string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileDescriptorProto.name"); auto str = msg->mutable_name(); @@ -1955,7 +1955,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e // optional string package = 2; case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileDescriptorProto.package"); auto str = msg->mutable_package(); @@ -1975,7 +1975,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileDescriptorProto.dependency"); auto str = msg->add_dependency(); @@ -1997,7 +1997,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e case 4: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::DescriptorProto::_InternalParse; object = msg->add_message_type(); @@ -2015,7 +2015,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e case 5: { if (static_cast<::google::protobuf::uint8>(tag) != 42) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::EnumDescriptorProto::_InternalParse; object = msg->add_enum_type(); @@ -2033,7 +2033,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e case 6: { if (static_cast<::google::protobuf::uint8>(tag) != 50) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::ServiceDescriptorProto::_InternalParse; object = msg->add_service(); @@ -2051,7 +2051,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e case 7: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::FieldDescriptorProto::_InternalParse; object = msg->add_extension(); @@ -2068,7 +2068,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e // optional .google.protobuf.FileOptions options = 8; case 8: { if (static_cast<::google::protobuf::uint8>(tag) != 66) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::FileOptions::_InternalParse; object = msg->mutable_options(); @@ -2083,7 +2083,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e // optional .google.protobuf.SourceCodeInfo source_code_info = 9; case 9: { if (static_cast<::google::protobuf::uint8>(tag) != 74) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::SourceCodeInfo::_InternalParse; object = msg->mutable_source_code_info(); @@ -2108,7 +2108,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e } while ((::google::protobuf::io::UnalignedLoad<::google::protobuf::uint64>(ptr) & 255) == 80 && (ptr += 1)); break; } else if (static_cast<::google::protobuf::uint8>(tag) != 82) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::internal::PackedInt32Parser; object = msg->mutable_public_dependency(); @@ -2131,7 +2131,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e } while ((::google::protobuf::io::UnalignedLoad<::google::protobuf::uint64>(ptr) & 255) == 88 && (ptr += 1)); break; } else if (static_cast<::google::protobuf::uint8>(tag) != 90) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::internal::PackedInt32Parser; object = msg->mutable_weak_dependency(); @@ -2144,7 +2144,7 @@ const char* FileDescriptorProto::_InternalParse(const char* begin, const char* e // optional string syntax = 12; case 12: { if (static_cast<::google::protobuf::uint8>(tag) != 98) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileDescriptorProto.syntax"); auto str = msg->mutable_syntax(); @@ -2970,7 +2970,7 @@ void DescriptorProto_ExtensionRange::Clear() { const char* DescriptorProto_ExtensionRange::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -3002,7 +3002,7 @@ const char* DescriptorProto_ExtensionRange::_InternalParse(const char* begin, co // optional .google.protobuf.ExtensionRangeOptions options = 3; case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::ExtensionRangeOptions::_InternalParse; object = msg->mutable_options(); @@ -3390,7 +3390,7 @@ void DescriptorProto_ReservedRange::Clear() { const char* DescriptorProto_ReservedRange::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -3820,7 +3820,7 @@ void DescriptorProto::Clear() { const char* DescriptorProto::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -3832,7 +3832,7 @@ const char* DescriptorProto::_InternalParse(const char* begin, const char* end, // optional string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.DescriptorProto.name"); auto str = msg->mutable_name(); @@ -3852,7 +3852,7 @@ const char* DescriptorProto::_InternalParse(const char* begin, const char* end, case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::FieldDescriptorProto::_InternalParse; object = msg->add_field(); @@ -3870,7 +3870,7 @@ const char* DescriptorProto::_InternalParse(const char* begin, const char* end, case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::DescriptorProto::_InternalParse; object = msg->add_nested_type(); @@ -3888,7 +3888,7 @@ const char* DescriptorProto::_InternalParse(const char* begin, const char* end, case 4: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::EnumDescriptorProto::_InternalParse; object = msg->add_enum_type(); @@ -3906,7 +3906,7 @@ const char* DescriptorProto::_InternalParse(const char* begin, const char* end, case 5: { if (static_cast<::google::protobuf::uint8>(tag) != 42) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::DescriptorProto_ExtensionRange::_InternalParse; object = msg->add_extension_range(); @@ -3924,7 +3924,7 @@ const char* DescriptorProto::_InternalParse(const char* begin, const char* end, case 6: { if (static_cast<::google::protobuf::uint8>(tag) != 50) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::FieldDescriptorProto::_InternalParse; object = msg->add_extension(); @@ -3941,7 +3941,7 @@ const char* DescriptorProto::_InternalParse(const char* begin, const char* end, // optional .google.protobuf.MessageOptions options = 7; case 7: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::MessageOptions::_InternalParse; object = msg->mutable_options(); @@ -3957,7 +3957,7 @@ const char* DescriptorProto::_InternalParse(const char* begin, const char* end, case 8: { if (static_cast<::google::protobuf::uint8>(tag) != 66) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::OneofDescriptorProto::_InternalParse; object = msg->add_oneof_decl(); @@ -3975,7 +3975,7 @@ const char* DescriptorProto::_InternalParse(const char* begin, const char* end, case 9: { if (static_cast<::google::protobuf::uint8>(tag) != 74) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::DescriptorProto_ReservedRange::_InternalParse; object = msg->add_reserved_range(); @@ -3993,7 +3993,7 @@ const char* DescriptorProto::_InternalParse(const char* begin, const char* end, case 10: { if (static_cast<::google::protobuf::uint8>(tag) != 82) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.DescriptorProto.reserved_name"); auto str = msg->add_reserved_name(); @@ -4694,7 +4694,7 @@ void ExtensionRangeOptions::Clear() { const char* ExtensionRangeOptions::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -4707,7 +4707,7 @@ const char* ExtensionRangeOptions::_InternalParse(const char* begin, const char* case 999: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::UninterpretedOption::_InternalParse; object = msg->add_uninterpreted_option(); @@ -5175,7 +5175,7 @@ void FieldDescriptorProto::Clear() { const char* FieldDescriptorProto::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -5187,7 +5187,7 @@ const char* FieldDescriptorProto::_InternalParse(const char* begin, const char* // optional string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FieldDescriptorProto.name"); auto str = msg->mutable_name(); @@ -5206,7 +5206,7 @@ const char* FieldDescriptorProto::_InternalParse(const char* begin, const char* // optional string extendee = 2; case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FieldDescriptorProto.extendee"); auto str = msg->mutable_extendee(); @@ -5263,7 +5263,7 @@ const char* FieldDescriptorProto::_InternalParse(const char* begin, const char* // optional string type_name = 6; case 6: { if (static_cast<::google::protobuf::uint8>(tag) != 50) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FieldDescriptorProto.type_name"); auto str = msg->mutable_type_name(); @@ -5282,7 +5282,7 @@ const char* FieldDescriptorProto::_InternalParse(const char* begin, const char* // optional string default_value = 7; case 7: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FieldDescriptorProto.default_value"); auto str = msg->mutable_default_value(); @@ -5301,7 +5301,7 @@ const char* FieldDescriptorProto::_InternalParse(const char* begin, const char* // optional .google.protobuf.FieldOptions options = 8; case 8: { if (static_cast<::google::protobuf::uint8>(tag) != 66) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::FieldOptions::_InternalParse; object = msg->mutable_options(); @@ -5326,7 +5326,7 @@ const char* FieldDescriptorProto::_InternalParse(const char* begin, const char* // optional string json_name = 10; case 10: { if (static_cast<::google::protobuf::uint8>(tag) != 82) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FieldDescriptorProto.json_name"); auto str = msg->mutable_json_name(); @@ -6079,7 +6079,7 @@ void OneofDescriptorProto::Clear() { const char* OneofDescriptorProto::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -6091,7 +6091,7 @@ const char* OneofDescriptorProto::_InternalParse(const char* begin, const char* // optional string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.OneofDescriptorProto.name"); auto str = msg->mutable_name(); @@ -6110,7 +6110,7 @@ const char* OneofDescriptorProto::_InternalParse(const char* begin, const char* // optional .google.protobuf.OneofOptions options = 2; case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::OneofOptions::_InternalParse; object = msg->mutable_options(); @@ -6477,7 +6477,7 @@ void EnumDescriptorProto_EnumReservedRange::Clear() { const char* EnumDescriptorProto_EnumReservedRange::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -6887,7 +6887,7 @@ void EnumDescriptorProto::Clear() { const char* EnumDescriptorProto::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -6899,7 +6899,7 @@ const char* EnumDescriptorProto::_InternalParse(const char* begin, const char* e // optional string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.EnumDescriptorProto.name"); auto str = msg->mutable_name(); @@ -6919,7 +6919,7 @@ const char* EnumDescriptorProto::_InternalParse(const char* begin, const char* e case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::EnumValueDescriptorProto::_InternalParse; object = msg->add_value(); @@ -6936,7 +6936,7 @@ const char* EnumDescriptorProto::_InternalParse(const char* begin, const char* e // optional .google.protobuf.EnumOptions options = 3; case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::EnumOptions::_InternalParse; object = msg->mutable_options(); @@ -6952,7 +6952,7 @@ const char* EnumDescriptorProto::_InternalParse(const char* begin, const char* e case 4: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::EnumDescriptorProto_EnumReservedRange::_InternalParse; object = msg->add_reserved_range(); @@ -6970,7 +6970,7 @@ const char* EnumDescriptorProto::_InternalParse(const char* begin, const char* e case 5: { if (static_cast<::google::protobuf::uint8>(tag) != 42) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.EnumDescriptorProto.reserved_name"); auto str = msg->add_reserved_name(); @@ -7514,7 +7514,7 @@ void EnumValueDescriptorProto::Clear() { const char* EnumValueDescriptorProto::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -7526,7 +7526,7 @@ const char* EnumValueDescriptorProto::_InternalParse(const char* begin, const ch // optional string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.EnumValueDescriptorProto.name"); auto str = msg->mutable_name(); @@ -7555,7 +7555,7 @@ const char* EnumValueDescriptorProto::_InternalParse(const char* begin, const ch // optional .google.protobuf.EnumValueOptions options = 3; case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::EnumValueOptions::_InternalParse; object = msg->mutable_options(); @@ -7995,7 +7995,7 @@ void ServiceDescriptorProto::Clear() { const char* ServiceDescriptorProto::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -8007,7 +8007,7 @@ const char* ServiceDescriptorProto::_InternalParse(const char* begin, const char // optional string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.ServiceDescriptorProto.name"); auto str = msg->mutable_name(); @@ -8027,7 +8027,7 @@ const char* ServiceDescriptorProto::_InternalParse(const char* begin, const char case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::MethodDescriptorProto::_InternalParse; object = msg->add_method(); @@ -8044,7 +8044,7 @@ const char* ServiceDescriptorProto::_InternalParse(const char* begin, const char // optional .google.protobuf.ServiceOptions options = 3; case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::ServiceOptions::_InternalParse; object = msg->mutable_options(); @@ -8531,7 +8531,7 @@ void MethodDescriptorProto::Clear() { const char* MethodDescriptorProto::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -8543,7 +8543,7 @@ const char* MethodDescriptorProto::_InternalParse(const char* begin, const char* // optional string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.MethodDescriptorProto.name"); auto str = msg->mutable_name(); @@ -8562,7 +8562,7 @@ const char* MethodDescriptorProto::_InternalParse(const char* begin, const char* // optional string input_type = 2; case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.MethodDescriptorProto.input_type"); auto str = msg->mutable_input_type(); @@ -8581,7 +8581,7 @@ const char* MethodDescriptorProto::_InternalParse(const char* begin, const char* // optional string output_type = 3; case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.MethodDescriptorProto.output_type"); auto str = msg->mutable_output_type(); @@ -8600,7 +8600,7 @@ const char* MethodDescriptorProto::_InternalParse(const char* begin, const char* // optional .google.protobuf.MethodOptions options = 4; case 4: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::MethodOptions::_InternalParse; object = msg->mutable_options(); @@ -9340,7 +9340,7 @@ void FileOptions::Clear() { const char* FileOptions::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -9352,7 +9352,7 @@ const char* FileOptions::_InternalParse(const char* begin, const char* end, void // optional string java_package = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileOptions.java_package"); auto str = msg->mutable_java_package(); @@ -9371,7 +9371,7 @@ const char* FileOptions::_InternalParse(const char* begin, const char* end, void // optional string java_outer_classname = 8; case 8: { if (static_cast<::google::protobuf::uint8>(tag) != 66) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileOptions.java_outer_classname"); auto str = msg->mutable_java_outer_classname(); @@ -9414,7 +9414,7 @@ const char* FileOptions::_InternalParse(const char* begin, const char* end, void // optional string go_package = 11; case 11: { if (static_cast<::google::protobuf::uint8>(tag) != 90) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileOptions.go_package"); auto str = msg->mutable_go_package(); @@ -9503,7 +9503,7 @@ const char* FileOptions::_InternalParse(const char* begin, const char* end, void // optional string objc_class_prefix = 36; case 36: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileOptions.objc_class_prefix"); auto str = msg->mutable_objc_class_prefix(); @@ -9522,7 +9522,7 @@ const char* FileOptions::_InternalParse(const char* begin, const char* end, void // optional string csharp_namespace = 37; case 37: { if (static_cast<::google::protobuf::uint8>(tag) != 42) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileOptions.csharp_namespace"); auto str = msg->mutable_csharp_namespace(); @@ -9541,7 +9541,7 @@ const char* FileOptions::_InternalParse(const char* begin, const char* end, void // optional string swift_prefix = 39; case 39: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileOptions.swift_prefix"); auto str = msg->mutable_swift_prefix(); @@ -9560,7 +9560,7 @@ const char* FileOptions::_InternalParse(const char* begin, const char* end, void // optional string php_class_prefix = 40; case 40: { if (static_cast<::google::protobuf::uint8>(tag) != 66) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileOptions.php_class_prefix"); auto str = msg->mutable_php_class_prefix(); @@ -9579,7 +9579,7 @@ const char* FileOptions::_InternalParse(const char* begin, const char* end, void // optional string php_namespace = 41; case 41: { if (static_cast<::google::protobuf::uint8>(tag) != 74) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileOptions.php_namespace"); auto str = msg->mutable_php_namespace(); @@ -9608,7 +9608,7 @@ const char* FileOptions::_InternalParse(const char* begin, const char* end, void // optional string php_metadata_namespace = 44; case 44: { if (static_cast<::google::protobuf::uint8>(tag) != 98) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileOptions.php_metadata_namespace"); auto str = msg->mutable_php_metadata_namespace(); @@ -9627,7 +9627,7 @@ const char* FileOptions::_InternalParse(const char* begin, const char* end, void // optional string ruby_package = 45; case 45: { if (static_cast<::google::protobuf::uint8>(tag) != 106) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FileOptions.ruby_package"); auto str = msg->mutable_ruby_package(); @@ -9647,7 +9647,7 @@ const char* FileOptions::_InternalParse(const char* begin, const char* end, void case 999: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::UninterpretedOption::_InternalParse; object = msg->add_uninterpreted_option(); @@ -10834,7 +10834,7 @@ void MessageOptions::Clear() { const char* MessageOptions::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -10887,7 +10887,7 @@ const char* MessageOptions::_InternalParse(const char* begin, const char* end, v case 999: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::UninterpretedOption::_InternalParse; object = msg->add_uninterpreted_option(); @@ -11395,7 +11395,7 @@ void FieldOptions::Clear() { const char* FieldOptions::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -11476,7 +11476,7 @@ const char* FieldOptions::_InternalParse(const char* begin, const char* end, voi case 999: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::UninterpretedOption::_InternalParse; object = msg->add_uninterpreted_option(); @@ -12030,7 +12030,7 @@ void OneofOptions::Clear() { const char* OneofOptions::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -12043,7 +12043,7 @@ const char* OneofOptions::_InternalParse(const char* begin, const char* end, voi case 999: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::UninterpretedOption::_InternalParse; object = msg->add_uninterpreted_option(); @@ -12395,7 +12395,7 @@ void EnumOptions::Clear() { const char* EnumOptions::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -12428,7 +12428,7 @@ const char* EnumOptions::_InternalParse(const char* begin, const char* end, void case 999: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::UninterpretedOption::_InternalParse; object = msg->add_uninterpreted_option(); @@ -12843,7 +12843,7 @@ void EnumValueOptions::Clear() { const char* EnumValueOptions::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -12866,7 +12866,7 @@ const char* EnumValueOptions::_InternalParse(const char* begin, const char* end, case 999: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::UninterpretedOption::_InternalParse; object = msg->add_uninterpreted_option(); @@ -13243,7 +13243,7 @@ void ServiceOptions::Clear() { const char* ServiceOptions::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -13266,7 +13266,7 @@ const char* ServiceOptions::_InternalParse(const char* begin, const char* end, v case 999: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::UninterpretedOption::_InternalParse; object = msg->add_uninterpreted_option(); @@ -13656,7 +13656,7 @@ void MethodOptions::Clear() { const char* MethodOptions::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -13693,7 +13693,7 @@ const char* MethodOptions::_InternalParse(const char* begin, const char* end, vo case 999: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::UninterpretedOption::_InternalParse; object = msg->add_uninterpreted_option(); @@ -14125,7 +14125,7 @@ void UninterpretedOption_NamePart::Clear() { const char* UninterpretedOption_NamePart::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -14137,7 +14137,7 @@ const char* UninterpretedOption_NamePart::_InternalParse(const char* begin, cons // required string name_part = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.UninterpretedOption.NamePart.name_part"); auto str = msg->mutable_name_part(); @@ -14583,7 +14583,7 @@ void UninterpretedOption::Clear() { const char* UninterpretedOption::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -14596,7 +14596,7 @@ const char* UninterpretedOption::_InternalParse(const char* begin, const char* e case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::UninterpretedOption_NamePart::_InternalParse; object = msg->add_name(); @@ -14613,7 +14613,7 @@ const char* UninterpretedOption::_InternalParse(const char* begin, const char* e // optional string identifier_value = 3; case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.UninterpretedOption.identifier_value"); auto str = msg->mutable_identifier_value(); @@ -14661,7 +14661,7 @@ const char* UninterpretedOption::_InternalParse(const char* begin, const char* e // optional bytes string_value = 7; case 7: { if (static_cast<::google::protobuf::uint8>(tag) != 58) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); auto str = msg->mutable_string_value(); if (size > end - ptr + ::google::protobuf::internal::ParseContext::kSlopBytes) { @@ -14679,7 +14679,7 @@ const char* UninterpretedOption::_InternalParse(const char* begin, const char* e // optional string aggregate_value = 8; case 8: { if (static_cast<::google::protobuf::uint8>(tag) != 66) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.UninterpretedOption.aggregate_value"); auto str = msg->mutable_aggregate_value(); @@ -15264,7 +15264,7 @@ void SourceCodeInfo_Location::Clear() { const char* SourceCodeInfo_Location::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -15276,7 +15276,7 @@ const char* SourceCodeInfo_Location::_InternalParse(const char* begin, const cha // repeated int32 path = 1 [packed = true]; case 1: { if (static_cast<::google::protobuf::uint8>(tag) == 10) { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::internal::PackedInt32Parser; object = msg->mutable_path(); @@ -15299,7 +15299,7 @@ const char* SourceCodeInfo_Location::_InternalParse(const char* begin, const cha // repeated int32 span = 2 [packed = true]; case 2: { if (static_cast<::google::protobuf::uint8>(tag) == 18) { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::internal::PackedInt32Parser; object = msg->mutable_span(); @@ -15322,7 +15322,7 @@ const char* SourceCodeInfo_Location::_InternalParse(const char* begin, const cha // optional string leading_comments = 3; case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.SourceCodeInfo.Location.leading_comments"); auto str = msg->mutable_leading_comments(); @@ -15341,7 +15341,7 @@ const char* SourceCodeInfo_Location::_InternalParse(const char* begin, const cha // optional string trailing_comments = 4; case 4: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.SourceCodeInfo.Location.trailing_comments"); auto str = msg->mutable_trailing_comments(); @@ -15361,7 +15361,7 @@ const char* SourceCodeInfo_Location::_InternalParse(const char* begin, const cha case 6: { if (static_cast<::google::protobuf::uint8>(tag) != 50) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.SourceCodeInfo.Location.leading_detached_comments"); auto str = msg->add_leading_detached_comments(); @@ -15890,7 +15890,7 @@ void SourceCodeInfo::Clear() { const char* SourceCodeInfo::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -15903,7 +15903,7 @@ const char* SourceCodeInfo::_InternalParse(const char* begin, const char* end, v case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::SourceCodeInfo_Location::_InternalParse; object = msg->add_location(); @@ -16239,7 +16239,7 @@ void GeneratedCodeInfo_Annotation::Clear() { const char* GeneratedCodeInfo_Annotation::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -16251,7 +16251,7 @@ const char* GeneratedCodeInfo_Annotation::_InternalParse(const char* begin, cons // repeated int32 path = 1 [packed = true]; case 1: { if (static_cast<::google::protobuf::uint8>(tag) == 10) { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::internal::PackedInt32Parser; object = msg->mutable_path(); @@ -16274,7 +16274,7 @@ const char* GeneratedCodeInfo_Annotation::_InternalParse(const char* begin, cons // optional string source_file = 2; case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.GeneratedCodeInfo.Annotation.source_file"); auto str = msg->mutable_source_file(); @@ -16739,7 +16739,7 @@ void GeneratedCodeInfo::Clear() { const char* GeneratedCodeInfo::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -16752,7 +16752,7 @@ const char* GeneratedCodeInfo::_InternalParse(const char* begin, const char* end case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::GeneratedCodeInfo_Annotation::_InternalParse; object = msg->add_annotation(); diff --git a/src/google/protobuf/descriptor.pb.h b/src/google/protobuf/descriptor.pb.h index 5ec9398fd5..1860184627 100644 --- a/src/google/protobuf/descriptor.pb.h +++ b/src/google/protobuf/descriptor.pb.h @@ -301,7 +301,8 @@ inline bool MethodOptions_IdempotencyLevel_Parse( } // =================================================================== -class PROTOBUF_EXPORT FileDescriptorSet : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorSet) */ { +class PROTOBUF_EXPORT FileDescriptorSet final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorSet) */ { public: FileDescriptorSet(); virtual ~FileDescriptorSet(); @@ -441,7 +442,8 @@ class PROTOBUF_EXPORT FileDescriptorSet : public ::google::protobuf::Message /* }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT FileDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorProto) */ { +class PROTOBUF_EXPORT FileDescriptorProto final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorProto) */ { public: FileDescriptorProto(); virtual ~FileDescriptorProto(); @@ -770,7 +772,8 @@ class PROTOBUF_EXPORT FileDescriptorProto : public ::google::protobuf::Message / }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT DescriptorProto_ExtensionRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ExtensionRange) */ { +class PROTOBUF_EXPORT DescriptorProto_ExtensionRange final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ExtensionRange) */ { public: DescriptorProto_ExtensionRange(); virtual ~DescriptorProto_ExtensionRange(); @@ -926,7 +929,8 @@ class PROTOBUF_EXPORT DescriptorProto_ExtensionRange : public ::google::protobuf }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT DescriptorProto_ReservedRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ReservedRange) */ { +class PROTOBUF_EXPORT DescriptorProto_ReservedRange final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ReservedRange) */ { public: DescriptorProto_ReservedRange(); virtual ~DescriptorProto_ReservedRange(); @@ -1069,7 +1073,8 @@ class PROTOBUF_EXPORT DescriptorProto_ReservedRange : public ::google::protobuf: }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT DescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto) */ { +class PROTOBUF_EXPORT DescriptorProto final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto) */ { public: DescriptorProto(); virtual ~DescriptorProto(); @@ -1351,7 +1356,8 @@ class PROTOBUF_EXPORT DescriptorProto : public ::google::protobuf::Message /* @@ }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT ExtensionRangeOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ExtensionRangeOptions) */ { +class PROTOBUF_EXPORT ExtensionRangeOptions final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ExtensionRangeOptions) */ { public: ExtensionRangeOptions(); virtual ~ExtensionRangeOptions(); @@ -1494,7 +1500,8 @@ class PROTOBUF_EXPORT ExtensionRangeOptions : public ::google::protobuf::Message }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT FieldDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldDescriptorProto) */ { +class PROTOBUF_EXPORT FieldDescriptorProto final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldDescriptorProto) */ { public: FieldDescriptorProto(); virtual ~FieldDescriptorProto(); @@ -1877,7 +1884,8 @@ class PROTOBUF_EXPORT FieldDescriptorProto : public ::google::protobuf::Message }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT OneofDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofDescriptorProto) */ { +class PROTOBUF_EXPORT OneofDescriptorProto final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofDescriptorProto) */ { public: OneofDescriptorProto(); virtual ~OneofDescriptorProto(); @@ -2042,7 +2050,8 @@ class PROTOBUF_EXPORT OneofDescriptorProto : public ::google::protobuf::Message }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT EnumDescriptorProto_EnumReservedRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto.EnumReservedRange) */ { +class PROTOBUF_EXPORT EnumDescriptorProto_EnumReservedRange final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto.EnumReservedRange) */ { public: EnumDescriptorProto_EnumReservedRange(); virtual ~EnumDescriptorProto_EnumReservedRange(); @@ -2185,7 +2194,8 @@ class PROTOBUF_EXPORT EnumDescriptorProto_EnumReservedRange : public ::google::p }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT EnumDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto) */ { +class PROTOBUF_EXPORT EnumDescriptorProto final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto) */ { public: EnumDescriptorProto(); virtual ~EnumDescriptorProto(); @@ -2401,7 +2411,8 @@ class PROTOBUF_EXPORT EnumDescriptorProto : public ::google::protobuf::Message / }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT EnumValueDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueDescriptorProto) */ { +class PROTOBUF_EXPORT EnumValueDescriptorProto final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueDescriptorProto) */ { public: EnumValueDescriptorProto(); virtual ~EnumValueDescriptorProto(); @@ -2574,7 +2585,8 @@ class PROTOBUF_EXPORT EnumValueDescriptorProto : public ::google::protobuf::Mess }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT ServiceDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceDescriptorProto) */ { +class PROTOBUF_EXPORT ServiceDescriptorProto final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceDescriptorProto) */ { public: ServiceDescriptorProto(); virtual ~ServiceDescriptorProto(); @@ -2752,7 +2764,8 @@ class PROTOBUF_EXPORT ServiceDescriptorProto : public ::google::protobuf::Messag }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT MethodDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodDescriptorProto) */ { +class PROTOBUF_EXPORT MethodDescriptorProto final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodDescriptorProto) */ { public: MethodDescriptorProto(); virtual ~MethodDescriptorProto(); @@ -2983,7 +2996,8 @@ class PROTOBUF_EXPORT MethodDescriptorProto : public ::google::protobuf::Message }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT FileOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileOptions) */ { +class PROTOBUF_EXPORT FileOptions final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileOptions) */ { public: FileOptions(); virtual ~FileOptions(); @@ -3484,7 +3498,8 @@ class PROTOBUF_EXPORT FileOptions : public ::google::protobuf::Message /* @@prot }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT MessageOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MessageOptions) */ { +class PROTOBUF_EXPORT MessageOptions final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MessageOptions) */ { public: MessageOptions(); virtual ~MessageOptions(); @@ -3659,7 +3674,8 @@ class PROTOBUF_EXPORT MessageOptions : public ::google::protobuf::Message /* @@p }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT FieldOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldOptions) */ { +class PROTOBUF_EXPORT FieldOptions final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldOptions) */ { public: FieldOptions(); virtual ~FieldOptions(); @@ -3906,7 +3922,8 @@ class PROTOBUF_EXPORT FieldOptions : public ::google::protobuf::Message /* @@pro }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT OneofOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofOptions) */ { +class PROTOBUF_EXPORT OneofOptions final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofOptions) */ { public: OneofOptions(); virtual ~OneofOptions(); @@ -4049,7 +4066,8 @@ class PROTOBUF_EXPORT OneofOptions : public ::google::protobuf::Message /* @@pro }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT EnumOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumOptions) */ { +class PROTOBUF_EXPORT EnumOptions final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumOptions) */ { public: EnumOptions(); virtual ~EnumOptions(); @@ -4208,7 +4226,8 @@ class PROTOBUF_EXPORT EnumOptions : public ::google::protobuf::Message /* @@prot }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT EnumValueOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueOptions) */ { +class PROTOBUF_EXPORT EnumValueOptions final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueOptions) */ { public: EnumValueOptions(); virtual ~EnumValueOptions(); @@ -4359,7 +4378,8 @@ class PROTOBUF_EXPORT EnumValueOptions : public ::google::protobuf::Message /* @ }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT ServiceOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceOptions) */ { +class PROTOBUF_EXPORT ServiceOptions final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceOptions) */ { public: ServiceOptions(); virtual ~ServiceOptions(); @@ -4510,7 +4530,8 @@ class PROTOBUF_EXPORT ServiceOptions : public ::google::protobuf::Message /* @@p }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT MethodOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodOptions) */ { +class PROTOBUF_EXPORT MethodOptions final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodOptions) */ { public: MethodOptions(); virtual ~MethodOptions(); @@ -4697,7 +4718,8 @@ class PROTOBUF_EXPORT MethodOptions : public ::google::protobuf::Message /* @@pr }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT UninterpretedOption_NamePart : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption.NamePart) */ { +class PROTOBUF_EXPORT UninterpretedOption_NamePart final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption.NamePart) */ { public: UninterpretedOption_NamePart(); virtual ~UninterpretedOption_NamePart(); @@ -4860,7 +4882,8 @@ class PROTOBUF_EXPORT UninterpretedOption_NamePart : public ::google::protobuf:: }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT UninterpretedOption : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption) */ { +class PROTOBUF_EXPORT UninterpretedOption final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption) */ { public: UninterpretedOption(); virtual ~UninterpretedOption(); @@ -5101,7 +5124,8 @@ class PROTOBUF_EXPORT UninterpretedOption : public ::google::protobuf::Message / }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT SourceCodeInfo_Location : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo.Location) */ { +class PROTOBUF_EXPORT SourceCodeInfo_Location final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo.Location) */ { public: SourceCodeInfo_Location(); virtual ~SourceCodeInfo_Location(); @@ -5329,7 +5353,8 @@ class PROTOBUF_EXPORT SourceCodeInfo_Location : public ::google::protobuf::Messa }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT SourceCodeInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo) */ { +class PROTOBUF_EXPORT SourceCodeInfo final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo) */ { public: SourceCodeInfo(); virtual ~SourceCodeInfo(); @@ -5471,7 +5496,8 @@ class PROTOBUF_EXPORT SourceCodeInfo : public ::google::protobuf::Message /* @@p }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT GeneratedCodeInfo_Annotation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo.Annotation) */ { +class PROTOBUF_EXPORT GeneratedCodeInfo_Annotation final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo.Annotation) */ { public: GeneratedCodeInfo_Annotation(); virtual ~GeneratedCodeInfo_Annotation(); @@ -5653,7 +5679,8 @@ class PROTOBUF_EXPORT GeneratedCodeInfo_Annotation : public ::google::protobuf:: }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT GeneratedCodeInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo) */ { +class PROTOBUF_EXPORT GeneratedCodeInfo final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo) */ { public: GeneratedCodeInfo(); virtual ~GeneratedCodeInfo(); diff --git a/src/google/protobuf/duration.pb.cc b/src/google/protobuf/duration.pb.cc index 41fdbec664..d4a0cb1172 100644 --- a/src/google/protobuf/duration.pb.cc +++ b/src/google/protobuf/duration.pb.cc @@ -176,7 +176,7 @@ void Duration::Clear() { const char* Duration::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; diff --git a/src/google/protobuf/duration.pb.h b/src/google/protobuf/duration.pb.h index a3b55d3afc..86c6b5b72c 100644 --- a/src/google/protobuf/duration.pb.h +++ b/src/google/protobuf/duration.pb.h @@ -61,7 +61,8 @@ namespace protobuf { // =================================================================== -class PROTOBUF_EXPORT Duration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Duration) */ { +class PROTOBUF_EXPORT Duration final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Duration) */ { public: Duration(); virtual ~Duration(); diff --git a/src/google/protobuf/empty.pb.cc b/src/google/protobuf/empty.pb.cc index 7f401fe032..a8d1d0171e 100644 --- a/src/google/protobuf/empty.pb.cc +++ b/src/google/protobuf/empty.pb.cc @@ -162,7 +162,7 @@ void Empty::Clear() { const char* Empty::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; diff --git a/src/google/protobuf/empty.pb.h b/src/google/protobuf/empty.pb.h index 2e64a6f24b..f9014394fd 100644 --- a/src/google/protobuf/empty.pb.h +++ b/src/google/protobuf/empty.pb.h @@ -61,7 +61,8 @@ namespace protobuf { // =================================================================== -class PROTOBUF_EXPORT Empty : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Empty) */ { +class PROTOBUF_EXPORT Empty final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Empty) */ { public: Empty(); virtual ~Empty(); diff --git a/src/google/protobuf/extension_set_unittest.cc b/src/google/protobuf/extension_set_unittest.cc index af398546d3..41278ef035 100644 --- a/src/google/protobuf/extension_set_unittest.cc +++ b/src/google/protobuf/extension_set_unittest.cc @@ -36,6 +36,7 @@ #include #include +#include #include #include #include @@ -59,6 +60,8 @@ namespace protobuf { namespace internal { namespace { +using TestUtil::EqualsToSerialized; + // This test closely mirrors net/proto2/compiler/cpp/internal/unittest.cc // except that it uses extensions rather than regular fields. @@ -660,7 +663,10 @@ TEST(ExtensionSetTest, PackedToUnpackedParsing) { // Reserialize unittest::TestUnpackedTypes unpacked; TestUtil::SetUnpackedFields(&unpacked); - EXPECT_TRUE(unpacked.SerializeAsString() == destination.SerializeAsString()); + // Serialized proto has to be the same size and parsed to the same message. + EXPECT_EQ(unpacked.SerializeAsString().size(), + destination.SerializeAsString().size()); + EXPECT_TRUE(EqualsToSerialized(unpacked, destination.SerializeAsString())); // Make sure we can add extensions. destination.AddExtension(unittest::unpacked_int32_extension, 1); @@ -681,7 +687,10 @@ TEST(ExtensionSetTest, UnpackedToPackedParsing) { // Reserialize unittest::TestPackedTypes packed; TestUtil::SetPackedFields(&packed); - EXPECT_TRUE(packed.SerializeAsString() == destination.SerializeAsString()); + // Serialized proto has to be the same size and parsed to the same message. + EXPECT_EQ(packed.SerializeAsString().size(), + destination.SerializeAsString().size()); + EXPECT_TRUE(EqualsToSerialized(packed, destination.SerializeAsString())); // Make sure we can add extensions. destination.AddExtension(unittest::packed_int32_extension, 1); @@ -1193,6 +1202,7 @@ TEST(ExtensionSetTest, DynamicExtensions) { // Since the extensions were based off of the fields of TestDynamicExtensions, // we can use that message to create this test message. string data; + unittest::TestDynamicExtensions dynamic_extension; { unittest::TestDynamicExtensions message; message.set_scalar_extension(123); @@ -1218,6 +1228,7 @@ TEST(ExtensionSetTest, DynamicExtensions) { message.mutable_unknown_fields()->AddLengthDelimited(54321, "unknown"); message.SerializeToString(&data); + dynamic_extension = message; } // Now we can parse this using our dynamic extension definitions... @@ -1252,9 +1263,8 @@ TEST(ExtensionSetTest, DynamicExtensions) { message.DebugString()); // Can we serialize it? - // (Don't use EXPECT_EQ because we don't want to dump raw binary data to the - // terminal on failure.) - EXPECT_TRUE(message.SerializeAsString() == data); + EXPECT_TRUE( + EqualsToSerialized(dynamic_extension, message.SerializeAsString())); // What if we parse using the reflection-based parser? { diff --git a/src/google/protobuf/field_mask.pb.cc b/src/google/protobuf/field_mask.pb.cc index f266ca2da1..b865a50c66 100644 --- a/src/google/protobuf/field_mask.pb.cc +++ b/src/google/protobuf/field_mask.pb.cc @@ -170,7 +170,7 @@ void FieldMask::Clear() { const char* FieldMask::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -183,7 +183,7 @@ const char* FieldMask::_InternalParse(const char* begin, const char* end, void* case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.FieldMask.paths"); auto str = msg->add_paths(); diff --git a/src/google/protobuf/field_mask.pb.h b/src/google/protobuf/field_mask.pb.h index 8ad3f6b9f5..a74e3b4b46 100644 --- a/src/google/protobuf/field_mask.pb.h +++ b/src/google/protobuf/field_mask.pb.h @@ -61,7 +61,8 @@ namespace protobuf { // =================================================================== -class PROTOBUF_EXPORT FieldMask : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldMask) */ { +class PROTOBUF_EXPORT FieldMask final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldMask) */ { public: FieldMask(); virtual ~FieldMask(); diff --git a/src/google/protobuf/io/coded_stream.h b/src/google/protobuf/io/coded_stream.h index 9bafafbccb..8d80d19f17 100644 --- a/src/google/protobuf/io/coded_stream.h +++ b/src/google/protobuf/io/coded_stream.h @@ -178,8 +178,8 @@ const char* VarintParse(const char* p, T* out) { res += byte << (i * 7); int j = i + 1; if (PROTOBUF_PREDICT_TRUE(byte < 128)) { - *out = res - extra; - return p + j; + *out = res - extra; + return p + j; } extra += 128ull << (i * 7); } @@ -193,6 +193,27 @@ inline const char* Parse64(const char* p, uint64* out) { return VarintParse<10>(p, out); } +inline const char* ReadSize(const char* p, int32* out) { + int32 res = 0; + int32 extra = 0; + for (int i = 0; i < 4; i++) { + uint32 byte = static_cast(p[i]); + res += byte << (i * 7); + int j = i + 1; + if (PROTOBUF_PREDICT_TRUE(byte < 128)) { + *out = res - extra; + return p + j; + } + extra += 128ull << (i * 7); + } + uint32 byte = static_cast(p[4]); + // size may not be negative, so only the lowest 3 bits can be set. + if (byte >= 8) return nullptr; + res += byte << (4 * 7); + *out = res - extra; + return p + 5; +} + // Class which reads and decodes binary data which is composed of varint- // encoded integers and fixed-width pieces. Wraps a ZeroCopyInputStream. // Most users will not need to deal with CodedInputStream. diff --git a/src/google/protobuf/map_field.cc b/src/google/protobuf/map_field.cc index 9b27a32e7e..8c86a6b0c0 100644 --- a/src/google/protobuf/map_field.cc +++ b/src/google/protobuf/map_field.cc @@ -91,12 +91,6 @@ void MapFieldBase::SetRepeatedDirty() { state_.store(STATE_MODIFIED_REPEATED, std::memory_order_relaxed); } -void MapFieldBase::SetClean() { - // These are called by (non-const) mutator functions. So by our API it's the - // callers responsibility to have these calls properly ordered. - state_.store(CLEAN, std::memory_order_relaxed); -} - void* MapFieldBase::MutableRepeatedPtrField() const { return repeated_field_; } void MapFieldBase::SyncRepeatedFieldWithMap() const { @@ -192,7 +186,9 @@ void DynamicMapField::Clear() { if (MapFieldBase::repeated_field_ != nullptr) { MapFieldBase::repeated_field_->Clear(); } - MapFieldBase::SetClean(); + // Data in map and repeated field are both empty, but we can't set status + // CLEAN which will invalidate previous reference to map. + MapFieldBase::SetMapDirty(); } bool DynamicMapField::ContainsMapKey( diff --git a/src/google/protobuf/map_field.h b/src/google/protobuf/map_field.h index 0bb559804f..ef1804b3cf 100644 --- a/src/google/protobuf/map_field.h +++ b/src/google/protobuf/map_field.h @@ -137,9 +137,6 @@ class PROTOBUF_EXPORT MapFieldBase { // Tells MapFieldBase that there is new change to RepeatedPTrField. void SetRepeatedDirty(); - // Tells MapFieldBase that map and repeated are the same. - void SetClean(); - // Provides derived class the access to repeated field. void* MutableRepeatedPtrField() const; diff --git a/src/google/protobuf/map_field_inl.h b/src/google/protobuf/map_field_inl.h index 40ceb50499..1e2fa496eb 100644 --- a/src/google/protobuf/map_field_inl.h +++ b/src/google/protobuf/map_field_inl.h @@ -186,7 +186,10 @@ void MapFieldclear(); - MapFieldBase::SetClean(); + // Data in map and repeated field are both empty, but we can't set status + // CLEAN. Because clear is a generated API, we cannot invalidate previous + // reference to map. + MapFieldBase::SetMapDirty(); } template Clear(); - Expect(map_field_.get(), CLEAN, 0, 0, false); + Expect(map_field_.get(), MAP_DIRTY, 0, 0, false); } TEST_P(MapFieldStateTest, SpaceUsedExcludingSelf) { diff --git a/src/google/protobuf/map_test_util.cc b/src/google/protobuf/map_test_util.cc index 25f027f305..7061946129 100644 --- a/src/google/protobuf/map_test_util.cc +++ b/src/google/protobuf/map_test_util.cc @@ -1584,8 +1584,6 @@ void MapReflectionTester::ExpectClearViaReflection( EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_foreign_message"))); EXPECT_TRUE(reflection->GetMapData( message, F("map_int32_foreign_message"))->IsMapValid()); - EXPECT_TRUE(reflection->GetMapData( - message, F("map_int32_foreign_message"))->IsRepeatedFieldValid()); } void MapReflectionTester::ExpectClearViaReflectionIterator( diff --git a/src/google/protobuf/message_lite.cc b/src/google/protobuf/message_lite.cc index fb1da49e54..2f1261ccdd 100644 --- a/src/google/protobuf/message_lite.cc +++ b/src/google/protobuf/message_lite.cc @@ -353,6 +353,10 @@ bool MessageLite::ParsePartialFromArray(const void* data, int size) { return ParseFrom(as_string_view(data, size)); } +bool MessageLite::MergeFromString(const string& data) { + return ParseFrom(data); +} + // =================================================================== diff --git a/src/google/protobuf/parse_context.h b/src/google/protobuf/parse_context.h index 4de3908114..20195bdc0d 100644 --- a/src/google/protobuf/parse_context.h +++ b/src/google/protobuf/parse_context.h @@ -347,8 +347,6 @@ class PROTOBUF_EXPORT ParseContext { const char* StoreAndTailCall(const char* ptr, const char* end, ParseClosure current_parser, ParseClosure child_parser, int32 size) { - // if size was bigger than 2GB we should fail - if (size < 0) return nullptr; // At this point ptr could be past end. Hence a malicious size could // overflow. int64 safe_new_limit = size - static_cast(end - ptr); @@ -650,8 +648,8 @@ std::pair FieldParser(uint64 tag, ParseClosure parent, break; } case WireType::WIRETYPE_LENGTH_DELIMITED: { - uint32 size; - ptr = io::Parse32(ptr, &size); + int32 size; + ptr = io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_ASSERT_RETURN(ptr != nullptr, {}); ParseClosure child = field_parser.AddLengthDelimited(number, size); if (size > end - ptr) { diff --git a/src/google/protobuf/source_context.pb.cc b/src/google/protobuf/source_context.pb.cc index ff0668be6b..e779fc961a 100644 --- a/src/google/protobuf/source_context.pb.cc +++ b/src/google/protobuf/source_context.pb.cc @@ -161,7 +161,7 @@ void SourceContext::Clear() { const char* SourceContext::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -173,7 +173,7 @@ const char* SourceContext::_InternalParse(const char* begin, const char* end, vo // string file_name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.SourceContext.file_name"); auto str = msg->mutable_file_name(); diff --git a/src/google/protobuf/source_context.pb.h b/src/google/protobuf/source_context.pb.h index b3d7834ce2..4ed899729d 100644 --- a/src/google/protobuf/source_context.pb.h +++ b/src/google/protobuf/source_context.pb.h @@ -61,7 +61,8 @@ namespace protobuf { // =================================================================== -class PROTOBUF_EXPORT SourceContext : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceContext) */ { +class PROTOBUF_EXPORT SourceContext final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceContext) */ { public: SourceContext(); virtual ~SourceContext(); diff --git a/src/google/protobuf/struct.pb.cc b/src/google/protobuf/struct.pb.cc index 317d5dc156..9e1740c23a 100644 --- a/src/google/protobuf/struct.pb.cc +++ b/src/google/protobuf/struct.pb.cc @@ -300,7 +300,7 @@ void Struct::Clear() { const char* Struct::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -313,7 +313,7 @@ const char* Struct::_InternalParse(const char* begin, const char* end, void* obj case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::internal::SlowMapEntryParser; auto parse_map = ::google::protobuf::Struct_FieldsEntry_DoNotUse::_ParseMap; @@ -844,7 +844,7 @@ void Value::Clear() { const char* Value::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -875,7 +875,7 @@ const char* Value::_InternalParse(const char* begin, const char* end, void* obje // string string_value = 3; case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Value.string_value"); auto str = msg->mutable_string_value(); @@ -904,7 +904,7 @@ const char* Value::_InternalParse(const char* begin, const char* end, void* obje // .google.protobuf.Struct struct_value = 5; case 5: { if (static_cast<::google::protobuf::uint8>(tag) != 42) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Struct::_InternalParse; object = msg->mutable_struct_value(); @@ -919,7 +919,7 @@ const char* Value::_InternalParse(const char* begin, const char* end, void* obje // .google.protobuf.ListValue list_value = 6; case 6: { if (static_cast<::google::protobuf::uint8>(tag) != 50) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::ListValue::_InternalParse; object = msg->mutable_list_value(); @@ -1406,7 +1406,7 @@ void ListValue::Clear() { const char* ListValue::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -1419,7 +1419,7 @@ const char* ListValue::_InternalParse(const char* begin, const char* end, void* case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Value::_InternalParse; object = msg->add_values(); diff --git a/src/google/protobuf/struct.pb.h b/src/google/protobuf/struct.pb.h index e44bcbd5ed..7d8040d7a4 100644 --- a/src/google/protobuf/struct.pb.h +++ b/src/google/protobuf/struct.pb.h @@ -121,7 +121,8 @@ static bool _ParseMap(const char* begin, const char* end, void* object, ::google // ------------------------------------------------------------------- -class PROTOBUF_EXPORT Struct : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Struct) */ { +class PROTOBUF_EXPORT Struct final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Struct) */ { public: Struct(); virtual ~Struct(); @@ -256,7 +257,8 @@ class PROTOBUF_EXPORT Struct : public ::google::protobuf::Message /* @@protoc_in }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT Value : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Value) */ { +class PROTOBUF_EXPORT Value final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Value) */ { public: Value(); virtual ~Value(); @@ -484,7 +486,8 @@ class PROTOBUF_EXPORT Value : public ::google::protobuf::Message /* @@protoc_ins }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT ListValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ListValue) */ { +class PROTOBUF_EXPORT ListValue final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ListValue) */ { public: ListValue(); virtual ~ListValue(); diff --git a/src/google/protobuf/stubs/strutil.h b/src/google/protobuf/stubs/strutil.h index e567ba7f0d..a9599cfe2e 100644 --- a/src/google/protobuf/stubs/strutil.h +++ b/src/google/protobuf/stubs/strutil.h @@ -620,16 +620,26 @@ struct PROTOBUF_EXPORT AlphaNum { // No bool ctor -- bools convert to an integral type. // A bool ctor would also convert incoming pointers (bletch). - AlphaNum(int32 i32) + AlphaNum(int i32) : piece_data_(digits), piece_size_(FastInt32ToBufferLeft(i32, digits) - &digits[0]) {} - AlphaNum(uint32 u32) + AlphaNum(unsigned int u32) : piece_data_(digits), piece_size_(FastUInt32ToBufferLeft(u32, digits) - &digits[0]) {} - AlphaNum(int64 i64) + AlphaNum(long long i64) : piece_data_(digits), piece_size_(FastInt64ToBufferLeft(i64, digits) - &digits[0]) {} - AlphaNum(uint64 u64) + AlphaNum(unsigned long long u64) + : piece_data_(digits), + piece_size_(FastUInt64ToBufferLeft(u64, digits) - &digits[0]) {} + + // Note: on some architectures, "long" is only 32 bits, not 64, but the + // performance hit of using FastInt64ToBufferLeft to handle 32-bit values + // is quite minor. + AlphaNum(long i64) + : piece_data_(digits), + piece_size_(FastInt64ToBufferLeft(i64, digits) - &digits[0]) {} + AlphaNum(unsigned long u64) : piece_data_(digits), piece_size_(FastUInt64ToBufferLeft(u64, digits) - &digits[0]) {} diff --git a/src/google/protobuf/stubs/strutil_unittest.cc b/src/google/protobuf/stubs/strutil_unittest.cc index 9460a66582..f830e37704 100644 --- a/src/google/protobuf/stubs/strutil_unittest.cc +++ b/src/google/protobuf/stubs/strutil_unittest.cc @@ -805,6 +805,37 @@ TEST(Base64, EscapeAndUnescape) { } } +// Test StrCat of ints and longs of various sizes and signdedness. +TEST(StrCat, Ints) { + const short s = -1; // NOLINT(runtime/int) + const uint16_t us = 2; + const int i = -3; + const unsigned int ui = 4; + const long l = -5; // NOLINT(runtime/int) + const unsigned long ul = 6; // NOLINT(runtime/int) + const long long ll = -7; // NOLINT(runtime/int) + const unsigned long long ull = 8; // NOLINT(runtime/int) + const ptrdiff_t ptrdiff = -9; + const size_t size = 10; + const intptr_t intptr = -12; + const uintptr_t uintptr = 13; + string answer; + answer = StrCat(s, us); + EXPECT_EQ(answer, "-12"); + answer = StrCat(i, ui); + EXPECT_EQ(answer, "-34"); + answer = StrCat(l, ul); + EXPECT_EQ(answer, "-56"); + answer = StrCat(ll, ull); + EXPECT_EQ(answer, "-78"); + answer = StrCat(ptrdiff, size); + EXPECT_EQ(answer, "-910"); + answer = StrCat(ptrdiff, intptr); + EXPECT_EQ(answer, "-9-12"); + answer = StrCat(uintptr, 0); + EXPECT_EQ(answer, "130"); +} + } // anonymous namespace } // namespace protobuf } // namespace google diff --git a/src/google/protobuf/test_util2.h b/src/google/protobuf/test_util2.h index d729808d5b..299311dc6f 100644 --- a/src/google/protobuf/test_util2.h +++ b/src/google/protobuf/test_util2.h @@ -33,6 +33,7 @@ #include +#include #include @@ -66,6 +67,15 @@ inline ::std::string GetTestDataPath(const ::std::string& google3_path) { return TestSourceDir() + "/" + MaybeTranslatePath(google3_path); } +// Checks the equality of "message" and serialized proto of type "ProtoType". +// Do not directly compare two serialized protos. +template +bool EqualsToSerialized(const ProtoType& message, const std::string& data) { + ProtoType other; + other.ParsePartialFromString(data); + return util::MessageDifferencer::Equals(message, other); +} + } // namespace TestUtil } // namespace protobuf } // namespace google diff --git a/src/google/protobuf/timestamp.pb.cc b/src/google/protobuf/timestamp.pb.cc index bf30404af1..acc7b9b8dd 100644 --- a/src/google/protobuf/timestamp.pb.cc +++ b/src/google/protobuf/timestamp.pb.cc @@ -176,7 +176,7 @@ void Timestamp::Clear() { const char* Timestamp::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; diff --git a/src/google/protobuf/timestamp.pb.h b/src/google/protobuf/timestamp.pb.h index ccb2890a81..f49ca7a260 100644 --- a/src/google/protobuf/timestamp.pb.h +++ b/src/google/protobuf/timestamp.pb.h @@ -61,7 +61,8 @@ namespace protobuf { // =================================================================== -class PROTOBUF_EXPORT Timestamp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Timestamp) */ { +class PROTOBUF_EXPORT Timestamp final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Timestamp) */ { public: Timestamp(); virtual ~Timestamp(); diff --git a/src/google/protobuf/type.pb.cc b/src/google/protobuf/type.pb.cc index 1696bfa965..c187394719 100644 --- a/src/google/protobuf/type.pb.cc +++ b/src/google/protobuf/type.pb.cc @@ -503,7 +503,7 @@ void Type::Clear() { const char* Type::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -515,7 +515,7 @@ const char* Type::_InternalParse(const char* begin, const char* end, void* objec // string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Type.name"); auto str = msg->mutable_name(); @@ -535,7 +535,7 @@ const char* Type::_InternalParse(const char* begin, const char* end, void* objec case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Field::_InternalParse; object = msg->add_fields(); @@ -553,7 +553,7 @@ const char* Type::_InternalParse(const char* begin, const char* end, void* objec case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Type.oneofs"); auto str = msg->add_oneofs(); @@ -575,7 +575,7 @@ const char* Type::_InternalParse(const char* begin, const char* end, void* objec case 4: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Option::_InternalParse; object = msg->add_options(); @@ -592,7 +592,7 @@ const char* Type::_InternalParse(const char* begin, const char* end, void* objec // .google.protobuf.SourceContext source_context = 5; case 5: { if (static_cast<::google::protobuf::uint8>(tag) != 42) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::SourceContext::_InternalParse; object = msg->mutable_source_context(); @@ -1155,7 +1155,7 @@ void Field::Clear() { const char* Field::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -1197,7 +1197,7 @@ const char* Field::_InternalParse(const char* begin, const char* end, void* obje // string name = 4; case 4: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Field.name"); auto str = msg->mutable_name(); @@ -1216,7 +1216,7 @@ const char* Field::_InternalParse(const char* begin, const char* end, void* obje // string type_url = 6; case 6: { if (static_cast<::google::protobuf::uint8>(tag) != 50) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Field.type_url"); auto str = msg->mutable_type_url(); @@ -1256,7 +1256,7 @@ const char* Field::_InternalParse(const char* begin, const char* end, void* obje case 9: { if (static_cast<::google::protobuf::uint8>(tag) != 74) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Option::_InternalParse; object = msg->add_options(); @@ -1273,7 +1273,7 @@ const char* Field::_InternalParse(const char* begin, const char* end, void* obje // string json_name = 10; case 10: { if (static_cast<::google::protobuf::uint8>(tag) != 82) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Field.json_name"); auto str = msg->mutable_json_name(); @@ -1292,7 +1292,7 @@ const char* Field::_InternalParse(const char* begin, const char* end, void* obje // string default_value = 11; case 11: { if (static_cast<::google::protobuf::uint8>(tag) != 90) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Field.default_value"); auto str = msg->mutable_default_value(); @@ -2013,7 +2013,7 @@ void Enum::Clear() { const char* Enum::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -2025,7 +2025,7 @@ const char* Enum::_InternalParse(const char* begin, const char* end, void* objec // string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Enum.name"); auto str = msg->mutable_name(); @@ -2045,7 +2045,7 @@ const char* Enum::_InternalParse(const char* begin, const char* end, void* objec case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::EnumValue::_InternalParse; object = msg->add_enumvalue(); @@ -2063,7 +2063,7 @@ const char* Enum::_InternalParse(const char* begin, const char* end, void* objec case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Option::_InternalParse; object = msg->add_options(); @@ -2080,7 +2080,7 @@ const char* Enum::_InternalParse(const char* begin, const char* end, void* objec // .google.protobuf.SourceContext source_context = 4; case 4: { if (static_cast<::google::protobuf::uint8>(tag) != 34) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::SourceContext::_InternalParse; object = msg->mutable_source_context(); @@ -2560,7 +2560,7 @@ void EnumValue::Clear() { const char* EnumValue::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -2572,7 +2572,7 @@ const char* EnumValue::_InternalParse(const char* begin, const char* end, void* // string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.EnumValue.name"); auto str = msg->mutable_name(); @@ -2602,7 +2602,7 @@ const char* EnumValue::_InternalParse(const char* begin, const char* end, void* case 3: { if (static_cast<::google::protobuf::uint8>(tag) != 26) goto handle_unusual; do { - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Option::_InternalParse; object = msg->add_options(); @@ -3026,7 +3026,7 @@ void Option::Clear() { const char* Option::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -3038,7 +3038,7 @@ const char* Option::_InternalParse(const char* begin, const char* end, void* obj // string name = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.Option.name"); auto str = msg->mutable_name(); @@ -3057,7 +3057,7 @@ const char* Option::_InternalParse(const char* begin, const char* end, void* obj // .google.protobuf.Any value = 2; case 2: { if (static_cast<::google::protobuf::uint8>(tag) != 18) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); parser_till_end = ::google::protobuf::Any::_InternalParse; object = msg->mutable_value(); diff --git a/src/google/protobuf/type.pb.h b/src/google/protobuf/type.pb.h index fe39afb4a1..ce345ba9df 100644 --- a/src/google/protobuf/type.pb.h +++ b/src/google/protobuf/type.pb.h @@ -162,7 +162,8 @@ inline bool Syntax_Parse( } // =================================================================== -class PROTOBUF_EXPORT Type : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Type) */ { +class PROTOBUF_EXPORT Type final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Type) */ { public: Type(); virtual ~Type(); @@ -374,7 +375,8 @@ class PROTOBUF_EXPORT Type : public ::google::protobuf::Message /* @@protoc_inse }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT Field : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Field) */ { +class PROTOBUF_EXPORT Field final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Field) */ { public: Field(); virtual ~Field(); @@ -727,7 +729,8 @@ class PROTOBUF_EXPORT Field : public ::google::protobuf::Message /* @@protoc_ins }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT Enum : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Enum) */ { +class PROTOBUF_EXPORT Enum final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Enum) */ { public: Enum(); virtual ~Enum(); @@ -916,7 +919,8 @@ class PROTOBUF_EXPORT Enum : public ::google::protobuf::Message /* @@protoc_inse }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT EnumValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValue) */ { +class PROTOBUF_EXPORT EnumValue final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValue) */ { public: EnumValue(); virtual ~EnumValue(); @@ -1079,7 +1083,8 @@ class PROTOBUF_EXPORT EnumValue : public ::google::protobuf::Message /* @@protoc }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT Option : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Option) */ { +class PROTOBUF_EXPORT Option final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Option) */ { public: Option(); virtual ~Option(); diff --git a/src/google/protobuf/wrappers.pb.cc b/src/google/protobuf/wrappers.pb.cc index 0d6e413891..202c9f3ddc 100644 --- a/src/google/protobuf/wrappers.pb.cc +++ b/src/google/protobuf/wrappers.pb.cc @@ -390,7 +390,7 @@ void DoubleValue::Clear() { const char* DoubleValue::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -679,7 +679,7 @@ void FloatValue::Clear() { const char* FloatValue::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -968,7 +968,7 @@ void Int64Value::Clear() { const char* Int64Value::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -1260,7 +1260,7 @@ void UInt64Value::Clear() { const char* UInt64Value::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -1552,7 +1552,7 @@ void Int32Value::Clear() { const char* Int32Value::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -1844,7 +1844,7 @@ void UInt32Value::Clear() { const char* UInt32Value::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -2136,7 +2136,7 @@ void BoolValue::Clear() { const char* BoolValue::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -2433,7 +2433,7 @@ void StringValue::Clear() { const char* StringValue::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -2445,7 +2445,7 @@ const char* StringValue::_InternalParse(const char* begin, const char* end, void // string value = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); ctx->extra_parse_data().SetFieldName("google.protobuf.StringValue.value"); auto str = msg->mutable_value(); @@ -2758,7 +2758,7 @@ void BytesValue::Clear() { const char* BytesValue::_InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx) { auto msg = static_cast(object); - ::google::protobuf::uint32 size; (void)size; + ::google::protobuf::int32 size; (void)size; int depth; (void)depth; ::google::protobuf::uint32 tag; ::google::protobuf::internal::ParseFunc parser_till_end; (void)parser_till_end; @@ -2770,7 +2770,7 @@ const char* BytesValue::_InternalParse(const char* begin, const char* end, void* // bytes value = 1; case 1: { if (static_cast<::google::protobuf::uint8>(tag) != 10) goto handle_unusual; - ptr = ::google::protobuf::io::Parse32(ptr, &size); + ptr = ::google::protobuf::io::ReadSize(ptr, &size); GOOGLE_PROTOBUF_PARSER_ASSERT(ptr); auto str = msg->mutable_value(); if (size > end - ptr + ::google::protobuf::internal::ParseContext::kSlopBytes) { diff --git a/src/google/protobuf/wrappers.pb.h b/src/google/protobuf/wrappers.pb.h index 48559c25ea..11a76625e5 100644 --- a/src/google/protobuf/wrappers.pb.h +++ b/src/google/protobuf/wrappers.pb.h @@ -93,7 +93,8 @@ namespace protobuf { // =================================================================== -class PROTOBUF_EXPORT DoubleValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DoubleValue) */ { +class PROTOBUF_EXPORT DoubleValue final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DoubleValue) */ { public: DoubleValue(); virtual ~DoubleValue(); @@ -219,7 +220,8 @@ class PROTOBUF_EXPORT DoubleValue : public ::google::protobuf::Message /* @@prot }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT FloatValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FloatValue) */ { +class PROTOBUF_EXPORT FloatValue final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FloatValue) */ { public: FloatValue(); virtual ~FloatValue(); @@ -345,7 +347,8 @@ class PROTOBUF_EXPORT FloatValue : public ::google::protobuf::Message /* @@proto }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT Int64Value : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int64Value) */ { +class PROTOBUF_EXPORT Int64Value final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int64Value) */ { public: Int64Value(); virtual ~Int64Value(); @@ -471,7 +474,8 @@ class PROTOBUF_EXPORT Int64Value : public ::google::protobuf::Message /* @@proto }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT UInt64Value : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt64Value) */ { +class PROTOBUF_EXPORT UInt64Value final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt64Value) */ { public: UInt64Value(); virtual ~UInt64Value(); @@ -597,7 +601,8 @@ class PROTOBUF_EXPORT UInt64Value : public ::google::protobuf::Message /* @@prot }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT Int32Value : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int32Value) */ { +class PROTOBUF_EXPORT Int32Value final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int32Value) */ { public: Int32Value(); virtual ~Int32Value(); @@ -723,7 +728,8 @@ class PROTOBUF_EXPORT Int32Value : public ::google::protobuf::Message /* @@proto }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT UInt32Value : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt32Value) */ { +class PROTOBUF_EXPORT UInt32Value final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt32Value) */ { public: UInt32Value(); virtual ~UInt32Value(); @@ -849,7 +855,8 @@ class PROTOBUF_EXPORT UInt32Value : public ::google::protobuf::Message /* @@prot }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT BoolValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BoolValue) */ { +class PROTOBUF_EXPORT BoolValue final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BoolValue) */ { public: BoolValue(); virtual ~BoolValue(); @@ -975,7 +982,8 @@ class PROTOBUF_EXPORT BoolValue : public ::google::protobuf::Message /* @@protoc }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT StringValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.StringValue) */ { +class PROTOBUF_EXPORT StringValue final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.StringValue) */ { public: StringValue(); virtual ~StringValue(); @@ -1118,7 +1126,8 @@ class PROTOBUF_EXPORT StringValue : public ::google::protobuf::Message /* @@prot }; // ------------------------------------------------------------------- -class PROTOBUF_EXPORT BytesValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BytesValue) */ { +class PROTOBUF_EXPORT BytesValue final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BytesValue) */ { public: BytesValue(); virtual ~BytesValue();