| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. All rights reserved. |
| // https://developers.google.com/protocol-buffers/ |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| // Author: kenton@google.com (Kenton Varda) |
| // Based on original Protocol Buffers design by |
| // Sanjay Ghemawat, Jeff Dean, and others. |
| |
| #include "google/protobuf/compiler/csharp/csharp_helpers.h" |
| |
| #include <algorithm> |
| #include <limits> |
| #include <sstream> |
| #include <vector> |
| |
| #include "absl/container/flat_hash_set.h" |
| #include "absl/strings/ascii.h" |
| #include "absl/strings/str_replace.h" |
| #include "absl/strings/string_view.h" |
| #include "google/protobuf/compiler/csharp/csharp_enum_field.h" |
| #include "google/protobuf/compiler/csharp/csharp_field_base.h" |
| #include "google/protobuf/compiler/csharp/csharp_map_field.h" |
| #include "google/protobuf/compiler/csharp/csharp_message_field.h" |
| #include "google/protobuf/compiler/csharp/csharp_options.h" |
| #include "google/protobuf/compiler/csharp/csharp_primitive_field.h" |
| #include "google/protobuf/compiler/csharp/csharp_repeated_enum_field.h" |
| #include "google/protobuf/compiler/csharp/csharp_repeated_message_field.h" |
| #include "google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h" |
| #include "google/protobuf/compiler/csharp/csharp_wrapper_field.h" |
| #include "google/protobuf/compiler/csharp/names.h" |
| #include "google/protobuf/descriptor.pb.h" |
| |
| // Must be last. |
| #include "google/protobuf/port_def.inc" |
| |
| namespace google { |
| namespace protobuf { |
| namespace compiler { |
| namespace csharp { |
| |
| CSharpType GetCSharpType(FieldDescriptor::Type type) { |
| switch (type) { |
| case FieldDescriptor::TYPE_INT32: |
| return CSHARPTYPE_INT32; |
| case FieldDescriptor::TYPE_INT64: |
| return CSHARPTYPE_INT64; |
| case FieldDescriptor::TYPE_UINT32: |
| return CSHARPTYPE_UINT32; |
| case FieldDescriptor::TYPE_UINT64: |
| return CSHARPTYPE_UINT32; |
| case FieldDescriptor::TYPE_SINT32: |
| return CSHARPTYPE_INT32; |
| case FieldDescriptor::TYPE_SINT64: |
| return CSHARPTYPE_INT64; |
| case FieldDescriptor::TYPE_FIXED32: |
| return CSHARPTYPE_UINT32; |
| case FieldDescriptor::TYPE_FIXED64: |
| return CSHARPTYPE_UINT64; |
| case FieldDescriptor::TYPE_SFIXED32: |
| return CSHARPTYPE_INT32; |
| case FieldDescriptor::TYPE_SFIXED64: |
| return CSHARPTYPE_INT64; |
| case FieldDescriptor::TYPE_FLOAT: |
| return CSHARPTYPE_FLOAT; |
| case FieldDescriptor::TYPE_DOUBLE: |
| return CSHARPTYPE_DOUBLE; |
| case FieldDescriptor::TYPE_BOOL: |
| return CSHARPTYPE_BOOL; |
| case FieldDescriptor::TYPE_ENUM: |
| return CSHARPTYPE_ENUM; |
| case FieldDescriptor::TYPE_STRING: |
| return CSHARPTYPE_STRING; |
| case FieldDescriptor::TYPE_BYTES: |
| return CSHARPTYPE_BYTESTRING; |
| case FieldDescriptor::TYPE_GROUP: |
| return CSHARPTYPE_MESSAGE; |
| case FieldDescriptor::TYPE_MESSAGE: |
| return CSHARPTYPE_MESSAGE; |
| |
| // No default because we want the compiler to complain if any new |
| // types are added. |
| } |
| GOOGLE_LOG(FATAL)<< "Can't get here."; |
| return (CSharpType) -1; |
| } |
| |
| // Convert a string which is expected to be SHOUTY_CASE (but may not be *precisely* shouty) |
| // into a PascalCase string. Precise rules implemented: |
| |
| // Previous input character Current character Case |
| // Any Non-alphanumeric Skipped |
| // None - first char of input Alphanumeric Upper |
| // Non-letter (e.g. _ or 1) Alphanumeric Upper |
| // Numeric Alphanumeric Upper |
| // Lower letter Alphanumeric Same as current |
| // Upper letter Alphanumeric Lower |
| std::string ShoutyToPascalCase(const std::string& input) { |
| std::string result; |
| // Simple way of implementing "always start with upper" |
| char previous = '_'; |
| for (int i = 0; i < input.size(); i++) { |
| char current = input[i]; |
| if (!absl::ascii_isalnum(current)) { |
| previous = current; |
| continue; |
| } |
| if (!absl::ascii_isalnum(previous)) { |
| result += absl::ascii_toupper(current); |
| } else if (absl::ascii_isdigit(previous)) { |
| result += absl::ascii_toupper(current); |
| } else if (absl::ascii_islower(previous)) { |
| result += current; |
| } else { |
| result += absl::ascii_tolower(current); |
| } |
| previous = current; |
| } |
| return result; |
| } |
| |
| // Attempt to remove a prefix from a value, ignoring casing and skipping underscores. |
| // (foo, foo_bar) => bar - underscore after prefix is skipped |
| // (FOO, foo_bar) => bar - casing is ignored |
| // (foo_bar, foobarbaz) => baz - underscore in prefix is ignored |
| // (foobar, foo_barbaz) => baz - underscore in value is ignored |
| // (foo, bar) => bar - prefix isn't matched; return original value |
| std::string TryRemovePrefix(const std::string& prefix, const std::string& value) { |
| // First normalize to a lower-case no-underscores prefix to match against |
| std::string prefix_to_match = ""; |
| for (size_t i = 0; i < prefix.size(); i++) { |
| if (prefix[i] != '_') { |
| prefix_to_match += absl::ascii_tolower(prefix[i]); |
| } |
| } |
| |
| // This keeps track of how much of value we've consumed |
| size_t prefix_index, value_index; |
| for (prefix_index = 0, value_index = 0; |
| prefix_index < prefix_to_match.size() && value_index < value.size(); |
| value_index++) { |
| // Skip over underscores in the value |
| if (value[value_index] == '_') { |
| continue; |
| } |
| if (absl::ascii_tolower(value[value_index]) != prefix_to_match[prefix_index++]) { |
| // Failed to match the prefix - bail out early. |
| return value; |
| } |
| } |
| |
| // If we didn't finish looking through the prefix, we can't strip it. |
| if (prefix_index < prefix_to_match.size()) { |
| return value; |
| } |
| |
| // Step over any underscores after the prefix |
| while (value_index < value.size() && value[value_index] == '_') { |
| value_index++; |
| } |
| |
| // If there's nothing left (e.g. it was a prefix with only underscores afterwards), don't strip. |
| if (value_index == value.size()) { |
| return value; |
| } |
| |
| return value.substr(value_index); |
| } |
| |
| // Format the enum value name in a pleasant way for C#: |
| // - Strip the enum name as a prefix if possible |
| // - Convert to PascalCase. |
| // For example, an enum called Color with a value of COLOR_BLUE should |
| // result in an enum value in C# called just Blue |
| std::string GetEnumValueName(const std::string& enum_name, const std::string& enum_value_name) { |
| std::string stripped = TryRemovePrefix(enum_name, enum_value_name); |
| std::string result = ShoutyToPascalCase(stripped); |
| // Just in case we have an enum name of FOO and a value of FOO_2... make sure the returned |
| // string is a valid identifier. |
| if (absl::ascii_isdigit(result[0])) { |
| result = "_" + result; |
| } |
| return result; |
| } |
| |
| uint GetGroupEndTag(const Descriptor* descriptor) { |
| const Descriptor* containing_type = descriptor->containing_type(); |
| if (containing_type != NULL) { |
| const FieldDescriptor* field; |
| for (int i = 0; i < containing_type->field_count(); i++) { |
| field = containing_type->field(i); |
| if (field->type() == FieldDescriptor::Type::TYPE_GROUP && |
| field->message_type() == descriptor) { |
| return internal::WireFormatLite::MakeTag( |
| field->number(), internal::WireFormatLite::WIRETYPE_END_GROUP); |
| } |
| } |
| for (int i = 0; i < containing_type->extension_count(); i++) { |
| field = containing_type->extension(i); |
| if (field->type() == FieldDescriptor::Type::TYPE_GROUP && |
| field->message_type() == descriptor) { |
| return internal::WireFormatLite::MakeTag( |
| field->number(), internal::WireFormatLite::WIRETYPE_END_GROUP); |
| } |
| } |
| } else { |
| const FileDescriptor* containing_file = descriptor->file(); |
| if (containing_file != NULL) { |
| const FieldDescriptor* field; |
| for (int i = 0; i < containing_file->extension_count(); i++) { |
| field = containing_file->extension(i); |
| if (field->type() == FieldDescriptor::Type::TYPE_GROUP && |
| field->message_type() == descriptor) { |
| return internal::WireFormatLite::MakeTag( |
| field->number(), internal::WireFormatLite::WIRETYPE_END_GROUP); |
| } |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| std::string GetFullExtensionName(const FieldDescriptor* descriptor) { |
| if (descriptor->extension_scope()) { |
| return GetClassName(descriptor->extension_scope()) + ".Extensions." + GetPropertyName(descriptor); |
| } |
| else { |
| return GetExtensionClassUnqualifiedName(descriptor->file()) + "." + GetPropertyName(descriptor); |
| } |
| } |
| |
| // Groups are hacky: The name of the field is just the lower-cased name |
| // of the group type. In C#, though, we would like to retain the original |
| // capitalization of the type name. |
| std::string GetFieldName(const FieldDescriptor* descriptor) { |
| if (descriptor->type() == FieldDescriptor::TYPE_GROUP) { |
| return descriptor->message_type()->name(); |
| } else { |
| return descriptor->name(); |
| } |
| } |
| |
| std::string GetFieldConstantName(const FieldDescriptor* field) { |
| return GetPropertyName(field) + "FieldNumber"; |
| } |
| |
| std::string GetPropertyName(const FieldDescriptor* descriptor) { |
| // Names of members declared or overridden in the message. |
| static const auto& reserved_member_names = *new absl::flat_hash_set<absl::string_view>({ |
| "Types", |
| "Descriptor", |
| "Equals", |
| "ToString", |
| "GetHashCode", |
| "WriteTo", |
| "Clone", |
| "CalculateSize", |
| "MergeFrom", |
| "OnConstruction", |
| "Parser" |
| }); |
| |
| // TODO(jtattermusch): consider introducing csharp_property_name field option |
| std::string property_name = UnderscoresToPascalCase(GetFieldName(descriptor)); |
| // Avoid either our own type name or reserved names. |
| // There are various ways of ending up with naming collisions, but we try to avoid obvious |
| // ones. In particular, we avoid the names of all the members we generate. |
| // Note that we *don't* add an underscore for MemberwiseClone or GetType. Those generate |
| // warnings, but not errors; changing the name now could be a breaking change. |
| if (property_name == descriptor->containing_type()->name() |
| || reserved_member_names.find(property_name) != reserved_member_names.end()) { |
| property_name += "_"; |
| } |
| return property_name; |
| } |
| |
| std::string GetOneofCaseName(const FieldDescriptor* descriptor) { |
| // The name in a oneof case enum is the same as for the property, but as we always have a "None" |
| // value as well, we need to reserve that by appending an underscore. |
| std::string property_name = GetPropertyName(descriptor); |
| return property_name == "None" ? "None_" : property_name; |
| } |
| |
| // TODO: c&p from Java protoc plugin |
| // For encodings with fixed sizes, returns that size in bytes. Otherwise |
| // returns -1. |
| int GetFixedSize(FieldDescriptor::Type type) { |
| switch (type) { |
| case FieldDescriptor::TYPE_INT32 : return -1; |
| case FieldDescriptor::TYPE_INT64 : return -1; |
| case FieldDescriptor::TYPE_UINT32 : return -1; |
| case FieldDescriptor::TYPE_UINT64 : return -1; |
| case FieldDescriptor::TYPE_SINT32 : return -1; |
| case FieldDescriptor::TYPE_SINT64 : return -1; |
| case FieldDescriptor::TYPE_FIXED32 : return internal::WireFormatLite::kFixed32Size; |
| case FieldDescriptor::TYPE_FIXED64 : return internal::WireFormatLite::kFixed64Size; |
| case FieldDescriptor::TYPE_SFIXED32: return internal::WireFormatLite::kSFixed32Size; |
| case FieldDescriptor::TYPE_SFIXED64: return internal::WireFormatLite::kSFixed64Size; |
| case FieldDescriptor::TYPE_FLOAT : return internal::WireFormatLite::kFloatSize; |
| case FieldDescriptor::TYPE_DOUBLE : return internal::WireFormatLite::kDoubleSize; |
| |
| case FieldDescriptor::TYPE_BOOL : return internal::WireFormatLite::kBoolSize; |
| case FieldDescriptor::TYPE_ENUM : return -1; |
| |
| case FieldDescriptor::TYPE_STRING : return -1; |
| case FieldDescriptor::TYPE_BYTES : return -1; |
| case FieldDescriptor::TYPE_GROUP : return -1; |
| case FieldDescriptor::TYPE_MESSAGE : return -1; |
| |
| // No default because we want the compiler to complain if any new |
| // types are added. |
| } |
| GOOGLE_LOG(FATAL) << "Can't get here."; |
| return -1; |
| } |
| |
| static const char base64_chars[] = |
| "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; |
| |
| std::string StringToBase64(const std::string& input) { |
| std::string result; |
| size_t remaining = input.size(); |
| const unsigned char *src = (const unsigned char*) input.c_str(); |
| while (remaining > 2) { |
| result += base64_chars[src[0] >> 2]; |
| result += base64_chars[((src[0] & 0x3) << 4) | (src[1] >> 4)]; |
| result += base64_chars[((src[1] & 0xf) << 2) | (src[2] >> 6)]; |
| result += base64_chars[src[2] & 0x3f]; |
| remaining -= 3; |
| src += 3; |
| } |
| switch (remaining) { |
| case 2: |
| result += base64_chars[src[0] >> 2]; |
| result += base64_chars[((src[0] & 0x3) << 4) | (src[1] >> 4)]; |
| result += base64_chars[(src[1] & 0xf) << 2]; |
| result += '='; |
| src += 2; |
| break; |
| case 1: |
| result += base64_chars[src[0] >> 2]; |
| result += base64_chars[((src[0] & 0x3) << 4)]; |
| result += '='; |
| result += '='; |
| src += 1; |
| break; |
| } |
| return result; |
| } |
| |
| std::string FileDescriptorToBase64(const FileDescriptor* descriptor) { |
| std::string fdp_bytes; |
| FileDescriptorProto fdp; |
| descriptor->CopyTo(&fdp); |
| fdp.SerializeToString(&fdp_bytes); |
| return StringToBase64(fdp_bytes); |
| } |
| |
| FieldGeneratorBase* CreateFieldGenerator(const FieldDescriptor* descriptor, |
| int presenceIndex, |
| const Options* options) { |
| switch (descriptor->type()) { |
| case FieldDescriptor::TYPE_GROUP: |
| case FieldDescriptor::TYPE_MESSAGE: |
| if (descriptor->is_repeated()) { |
| if (descriptor->is_map()) { |
| return new MapFieldGenerator(descriptor, presenceIndex, options); |
| } else { |
| return new RepeatedMessageFieldGenerator(descriptor, presenceIndex, options); |
| } |
| } else { |
| if (IsWrapperType(descriptor)) { |
| if (descriptor->real_containing_oneof()) { |
| return new WrapperOneofFieldGenerator(descriptor, presenceIndex, options); |
| } else { |
| return new WrapperFieldGenerator(descriptor, presenceIndex, options); |
| } |
| } else { |
| if (descriptor->real_containing_oneof()) { |
| return new MessageOneofFieldGenerator(descriptor, presenceIndex, options); |
| } else { |
| return new MessageFieldGenerator(descriptor, presenceIndex, options); |
| } |
| } |
| } |
| case FieldDescriptor::TYPE_ENUM: |
| if (descriptor->is_repeated()) { |
| return new RepeatedEnumFieldGenerator(descriptor, presenceIndex, options); |
| } else { |
| if (descriptor->real_containing_oneof()) { |
| return new EnumOneofFieldGenerator(descriptor, presenceIndex, options); |
| } else { |
| return new EnumFieldGenerator(descriptor, presenceIndex, options); |
| } |
| } |
| default: |
| if (descriptor->is_repeated()) { |
| return new RepeatedPrimitiveFieldGenerator(descriptor, presenceIndex, options); |
| } else { |
| if (descriptor->real_containing_oneof()) { |
| return new PrimitiveOneofFieldGenerator(descriptor, presenceIndex, options); |
| } else { |
| return new PrimitiveFieldGenerator(descriptor, presenceIndex, options); |
| } |
| } |
| } |
| } |
| |
| bool IsNullable(const FieldDescriptor* descriptor) { |
| if (descriptor->is_repeated()) { |
| return true; |
| } |
| |
| switch (descriptor->type()) { |
| case FieldDescriptor::TYPE_ENUM: |
| case FieldDescriptor::TYPE_DOUBLE: |
| case FieldDescriptor::TYPE_FLOAT: |
| case FieldDescriptor::TYPE_INT64: |
| case FieldDescriptor::TYPE_UINT64: |
| case FieldDescriptor::TYPE_INT32: |
| case FieldDescriptor::TYPE_FIXED64: |
| case FieldDescriptor::TYPE_FIXED32: |
| case FieldDescriptor::TYPE_BOOL: |
| case FieldDescriptor::TYPE_UINT32: |
| case FieldDescriptor::TYPE_SFIXED32: |
| case FieldDescriptor::TYPE_SFIXED64: |
| case FieldDescriptor::TYPE_SINT32: |
| case FieldDescriptor::TYPE_SINT64: |
| return false; |
| |
| case FieldDescriptor::TYPE_MESSAGE: |
| case FieldDescriptor::TYPE_GROUP: |
| case FieldDescriptor::TYPE_STRING: |
| case FieldDescriptor::TYPE_BYTES: |
| return true; |
| |
| default: |
| GOOGLE_LOG(FATAL) << "Unknown field type."; |
| return true; |
| } |
| } |
| |
| } // namespace csharp |
| } // namespace compiler |
| } // namespace protobuf |
| } // namespace google |
| |
| #include "google/protobuf/port_undef.inc" |