| // 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. |
| |
| #include <sstream> |
| |
| #include <google/protobuf/compiler/code_generator.h> |
| #include <google/protobuf/compiler/plugin.h> |
| #include <google/protobuf/descriptor.h> |
| #include <google/protobuf/descriptor.pb.h> |
| #include <google/protobuf/io/printer.h> |
| #include <google/protobuf/io/zero_copy_stream.h> |
| #include <google/protobuf/stubs/strutil.h> |
| |
| |
| #include <google/protobuf/compiler/csharp/csharp_enum.h> |
| #include <google/protobuf/compiler/csharp/csharp_helpers.h> |
| #include <google/protobuf/compiler/csharp/csharp_message.h> |
| #include <google/protobuf/compiler/csharp/csharp_names.h> |
| #include <google/protobuf/compiler/csharp/csharp_options.h> |
| #include <google/protobuf/compiler/csharp/csharp_reflection_class.h> |
| |
| namespace google { |
| namespace protobuf { |
| namespace compiler { |
| namespace csharp { |
| |
| ReflectionClassGenerator::ReflectionClassGenerator(const FileDescriptor* file, |
| const Options* options) |
| : SourceGeneratorBase(file, options), |
| file_(file) { |
| namespace_ = GetFileNamespace(file); |
| reflectionClassname_ = GetReflectionClassUnqualifiedName(file); |
| } |
| |
| ReflectionClassGenerator::~ReflectionClassGenerator() { |
| } |
| |
| void ReflectionClassGenerator::Generate(io::Printer* printer) { |
| WriteIntroduction(printer); |
| |
| WriteDescriptor(printer); |
| // Close the class declaration. |
| printer->Outdent(); |
| printer->Print("}\n"); |
| |
| // write children: Enums |
| if (file_->enum_type_count() > 0) { |
| printer->Print("#region Enums\n"); |
| for (int i = 0; i < file_->enum_type_count(); i++) { |
| EnumGenerator enumGenerator(file_->enum_type(i), this->options()); |
| enumGenerator.Generate(printer); |
| } |
| printer->Print("#endregion\n"); |
| printer->Print("\n"); |
| } |
| |
| // write children: Messages |
| if (file_->message_type_count() > 0) { |
| printer->Print("#region Messages\n"); |
| for (int i = 0; i < file_->message_type_count(); i++) { |
| MessageGenerator messageGenerator(file_->message_type(i), this->options()); |
| messageGenerator.Generate(printer); |
| } |
| printer->Print("#endregion\n"); |
| printer->Print("\n"); |
| } |
| |
| // TODO(jtattermusch): add insertion point for services. |
| |
| if (!namespace_.empty()) { |
| printer->Outdent(); |
| printer->Print("}\n"); |
| } |
| printer->Print("\n"); |
| printer->Print("#endregion Designer generated code\n"); |
| } |
| |
| void ReflectionClassGenerator::WriteIntroduction(io::Printer* printer) { |
| printer->Print( |
| "// Generated by the protocol buffer compiler. DO NOT EDIT!\n" |
| "// source: $file_name$\n" |
| "#pragma warning disable 1591, 0612, 3021\n" |
| "#region Designer generated code\n" |
| "\n" |
| "using pb = global::Google.Protobuf;\n" |
| "using pbc = global::Google.Protobuf.Collections;\n" |
| "using pbr = global::Google.Protobuf.Reflection;\n" |
| "using scg = global::System.Collections.Generic;\n", |
| "file_name", file_->name()); |
| |
| if (!namespace_.empty()) { |
| printer->Print("namespace $namespace$ {\n", "namespace", namespace_); |
| printer->Indent(); |
| printer->Print("\n"); |
| } |
| |
| printer->Print( |
| "/// <summary>Holder for reflection information generated from $file_name$</summary>\n" |
| "[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]\n", |
| "file_name", file_->name()); |
| WriteGeneratedCodeAttributes(printer); |
| printer->Print( |
| "$access_level$ static partial class $reflection_class_name$ {\n" |
| "\n", |
| "access_level", class_access_level(), |
| "reflection_class_name", reflectionClassname_); |
| printer->Indent(); |
| } |
| |
| void ReflectionClassGenerator::WriteDescriptor(io::Printer* printer) { |
| printer->Print( |
| "#region Descriptor\n" |
| "/// <summary>File descriptor for $file_name$</summary>\n" |
| "public static pbr::FileDescriptor Descriptor {\n" |
| " get { return descriptor; }\n" |
| "}\n" |
| "private static pbr::FileDescriptor descriptor;\n" |
| "\n" |
| "static $reflection_class_name$() {\n", |
| "file_name", file_->name(), |
| "reflection_class_name", reflectionClassname_); |
| printer->Indent(); |
| printer->Print( |
| "byte[] descriptorData = global::System.Convert.FromBase64String(\n"); |
| printer->Indent(); |
| printer->Indent(); |
| printer->Print("string.Concat(\n"); |
| printer->Indent(); |
| |
| // TODO(jonskeet): Consider a C#-escaping format here instead of just Base64. |
| std::string base64 = FileDescriptorToBase64(file_); |
| while (base64.size() > 60) { |
| printer->Print("\"$base64$\",\n", "base64", base64.substr(0, 60)); |
| base64 = base64.substr(60); |
| } |
| printer->Print("\"$base64$\"));\n", "base64", base64); |
| printer->Outdent(); |
| printer->Outdent(); |
| printer->Outdent(); |
| |
| // ----------------------------------------------------------------- |
| // Invoke InternalBuildGeneratedFileFrom() to build the file. |
| printer->Print( |
| "descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,\n"); |
| printer->Print(" new pbr::FileDescriptor[] { "); |
| for (int i = 0; i < file_->dependency_count(); i++) { |
| // descriptor.proto is special: we don't allow access to the generated code, but there's |
| // a separately-exposed property to get at the file descriptor, specifically to allow this |
| // kind of dependency. |
| if (IsDescriptorProto(file_->dependency(i))) { |
| printer->Print("pbr::FileDescriptor.DescriptorProtoFileDescriptor, "); |
| } else { |
| printer->Print( |
| "$full_reflection_class_name$.Descriptor, ", |
| "full_reflection_class_name", |
| GetReflectionClassName(file_->dependency(i))); |
| } |
| } |
| printer->Print("},\n" |
| " new pbr::GeneratedClrTypeInfo("); |
| // Specify all the generated code information, recursively. |
| if (file_->enum_type_count() > 0) { |
| printer->Print("new[] {"); |
| for (int i = 0; i < file_->enum_type_count(); i++) { |
| printer->Print("typeof($type_name$), ", "type_name", GetClassName(file_->enum_type(i))); |
| } |
| printer->Print("}, "); |
| } |
| else { |
| printer->Print("null, "); |
| } |
| if (file_->message_type_count() > 0) { |
| printer->Print("new pbr::GeneratedClrTypeInfo[] {\n"); |
| printer->Indent(); |
| printer->Indent(); |
| printer->Indent(); |
| for (int i = 0; i < file_->message_type_count(); i++) { |
| WriteGeneratedCodeInfo(file_->message_type(i), printer, i == file_->message_type_count() - 1); |
| } |
| printer->Outdent(); |
| printer->Print("\n}));\n"); |
| printer->Outdent(); |
| printer->Outdent(); |
| } |
| else { |
| printer->Print("null));\n"); |
| } |
| |
| printer->Outdent(); |
| printer->Print("}\n"); |
| printer->Print("#endregion\n\n"); |
| } |
| |
| // Write out the generated code for a particular message. This consists of the CLR type, property names |
| // corresponding to fields, names corresponding to oneofs, nested enums, and nested types. Each array part |
| // can be specified as null if it would be empty, to make the generated code somewhat simpler to read. |
| // We write a line break at the end of each generated code info, so that in the final file we'll see all |
| // the types, pre-ordered depth first, one per line. The indentation will be slightly unusual, |
| // in that it will look like a single array when it's actually constructing a tree, but it'll be easy to |
| // read even with multiple levels of nesting. |
| // The "last" parameter indicates whether this message descriptor is the last one being printed in this immediate |
| // context. It governs whether or not a trailing comma and newline is written after the constructor, effectively |
| // just controlling the formatting in the generated code. |
| void ReflectionClassGenerator::WriteGeneratedCodeInfo(const Descriptor* descriptor, io::Printer* printer, bool last) { |
| if (IsMapEntryMessage(descriptor)) { |
| printer->Print("null, "); |
| return; |
| } |
| // Generated message type |
| printer->Print("new pbr::GeneratedClrTypeInfo(typeof($type_name$), $type_name$.Parser, ", "type_name", GetClassName(descriptor)); |
| |
| // Fields |
| if (descriptor->field_count() > 0) { |
| std::vector<std::string> fields; |
| for (int i = 0; i < descriptor->field_count(); i++) { |
| fields.push_back(GetPropertyName(descriptor->field(i))); |
| } |
| printer->Print("new[]{ \"$fields$\" }, ", "fields", JoinStrings(fields, "\", \"")); |
| } |
| else { |
| printer->Print("null, "); |
| } |
| |
| // Oneofs |
| if (descriptor->oneof_decl_count() > 0) { |
| std::vector<std::string> oneofs; |
| for (int i = 0; i < descriptor->oneof_decl_count(); i++) { |
| oneofs.push_back(UnderscoresToCamelCase(descriptor->oneof_decl(i)->name(), true)); |
| } |
| printer->Print("new[]{ \"$oneofs$\" }, ", "oneofs", JoinStrings(oneofs, "\", \"")); |
| } |
| else { |
| printer->Print("null, "); |
| } |
| |
| // Nested enums |
| if (descriptor->enum_type_count() > 0) { |
| std::vector<std::string> enums; |
| for (int i = 0; i < descriptor->enum_type_count(); i++) { |
| enums.push_back(GetClassName(descriptor->enum_type(i))); |
| } |
| printer->Print("new[]{ typeof($enums$) }, ", "enums", JoinStrings(enums, "), typeof(")); |
| } |
| else { |
| printer->Print("null, "); |
| } |
| |
| // Nested types |
| if (descriptor->nested_type_count() > 0) { |
| // Need to specify array type explicitly here, as all elements may be null. |
| printer->Print("new pbr::GeneratedClrTypeInfo[] { "); |
| for (int i = 0; i < descriptor->nested_type_count(); i++) { |
| WriteGeneratedCodeInfo(descriptor->nested_type(i), printer, i == descriptor->nested_type_count() - 1); |
| } |
| printer->Print("}"); |
| } |
| else { |
| printer->Print("null"); |
| } |
| printer->Print(last ? ")" : "),\n"); |
| } |
| |
| } // namespace csharp |
| } // namespace compiler |
| } // namespace protobuf |
| } // namespace google |