Add protoc plugin.

Original patch by igorgatis@gmail.com, tweaked a little before commit. Fixes issue 90.
author: Jon Skeet <skeet@pobox.com> 2014-08-02 21:57:54 +0100
committer: Jon Skeet <skeet@pobox.com> 2014-08-02 21:57:54 +0100
commit: 92d6214e0f76cc92f35f3a44aa89e0b0e60df5e8 (patch)
tree: c0f2a5106c67a90509e176837e9b29b2426fba4c /src/ProtoGen
parent: fd6c129298e1302c4a96c4d4b56b83f2dcc1838c (diff)
download: protobuf-92d6214e0f76cc92f35f3a44aa89e0b0e60df5e8.tar.gz
protobuf-92d6214e0f76cc92f35f3a44aa89e0b0e60df5e8.tar.bz2
protobuf-92d6214e0f76cc92f35f3a44aa89e0b0e60df5e8.zip
6 files changed, 1411 insertions, 27 deletions
diff --git a/src/ProtoGen/Generator.cs b/src/ProtoGen/Generator.cs
index e37d655e..91ca5c23 100644
--- a/src/ProtoGen/Generator.cs
+++ b/src/ProtoGen/Generator.cs
@@ -39,6 +39,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using Google.ProtocolBuffers.Collections;
+using Google.ProtocolBuffers.Compiler.PluginProto;
 using Google.ProtocolBuffers.DescriptorProtos;
 using Google.ProtocolBuffers.Descriptors;
 
@@ -65,20 +66,9 @@ namespace Google.ProtocolBuffers.ProtoGen
             return new Generator(options);
         }
 
-        public void Generate()
+        public void Generate(CodeGeneratorRequest request, CodeGeneratorResponse.Builder response)
         {
-            List<FileDescriptorSet> descriptorProtos = new List<FileDescriptorSet>();
-            foreach (string inputFile in options.InputFiles)
-            {
-                ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance();
-                CSharpOptions.RegisterAllExtensions(extensionRegistry);
-                using (Stream inputStream = File.OpenRead(inputFile))
-                {
-                    descriptorProtos.Add(FileDescriptorSet.ParseFrom(inputStream, extensionRegistry));
-                }
-            }
-
-            IList<FileDescriptor> descriptors = ConvertDescriptors(options.FileOptions, descriptorProtos.ToArray());
+            IList<FileDescriptor> descriptors = ConvertDescriptors(options.FileOptions, request.ProtoFileList);
 
             // Combine with options from command line
             foreach (FileDescriptor descriptor in descriptors)
@@ -99,6 +89,7 @@ namespace Google.ProtocolBuffers.ProtoGen
                 names.Add(file, true);
             }
 
+            var filesToGenerate = new HashSet<string>(request.FileToGenerateList);
             foreach (FileDescriptor descriptor in descriptors)
             {
                 // Optionally exclude descriptors in google.protobuf
@@ -106,7 +97,10 @@ namespace Google.ProtocolBuffers.ProtoGen
                 {
                     continue;
                 }
-                Generate(descriptor, duplicates);
+                if (filesToGenerate.Contains(descriptor.Name))
+                {
+                    Generate(descriptor, duplicates, response);
+                }
             }
         }
 
@@ -114,14 +108,20 @@ namespace Google.ProtocolBuffers.ProtoGen
         /// Generates code for a particular file. All dependencies must
         /// already have been resolved.
         /// </summary>
-        private void Generate(FileDescriptor descriptor, bool duplicates)
+        private void Generate(FileDescriptor descriptor, bool duplicates, CodeGeneratorResponse.Builder response)
         {
-            UmbrellaClassGenerator ucg = new UmbrellaClassGenerator(descriptor);
-            using (TextWriter textWriter = File.CreateText(GetOutputFile(descriptor, duplicates)))
+            var code = new StringBuilder();
+            var ucg = new UmbrellaClassGenerator(descriptor);
+            using (StringWriter textWriter = new StringWriter(code))
             {
                 TextGenerator writer = new TextGenerator(textWriter, options.LineBreak);
                 ucg.Generate(writer);
             }
+            response.AddFile(new CodeGeneratorResponse.Types.File.Builder
+            {
+                Name = GetOutputFile(descriptor, duplicates),
+                Content = code.ToString(),
+            }.Build());
         }
 
         private string GetOutputFile(FileDescriptor descriptor, bool duplicates)
@@ -164,16 +164,8 @@ namespace Google.ProtocolBuffers.ProtoGen
         /// </summary>
         /// <exception cref="DependencyResolutionException">Not all dependencies could be resolved.</exception>
         public static IList<FileDescriptor> ConvertDescriptors(CSharpFileOptions options,
-                                                               params FileDescriptorSet[] descriptorProtos)
+                                                               IList<FileDescriptorProto> fileList)
         {
-            // Simple strategy: Keep going through the list of protos to convert, only doing ones where
-            // we've already converted all the dependencies, until we get to a stalemate
-            List<FileDescriptorProto> fileList = new List<FileDescriptorProto>();
-            foreach (FileDescriptorSet set in descriptorProtos)
-            {
-                fileList.AddRange(set.FileList);
-            }
-
             FileDescriptor[] converted = new FileDescriptor[fileList.Count];
 
             Dictionary<string, FileDescriptor> convertedMap = new Dictionary<string, FileDescriptor>();
diff --git a/src/ProtoGen/PluginProtoFile.cs b/src/ProtoGen/PluginProtoFile.cs
new file mode 100644
index 00000000..e0fed5c3
--- /dev/null
+++ b/src/ProtoGen/PluginProtoFile.cs
@@ -0,0 +1,1187 @@
+// Generated by protoc-gen-cs, Version=2.4.1.521, Culture=neutral, PublicKeyToken=17b3b1f090c3ea48.  DO NOT EDIT!
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.ProtocolBuffers;
+using pbc = global::Google.ProtocolBuffers.Collections;
+using pbd = global::Google.ProtocolBuffers.Descriptors;
+using scg = global::System.Collections.Generic;
+namespace Google.ProtocolBuffers.Compiler.PluginProto {
+
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public static partial class Plugin {
+
+    #region Extension registration
+    public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
+    }
+    #endregion
+    #region Static variables
+    internal static pbd::MessageDescriptor internal__static_google_protobuf_compiler_CodeGeneratorRequest__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorRequest, global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorRequest.Builder> internal__static_google_protobuf_compiler_CodeGeneratorRequest__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_google_protobuf_compiler_CodeGeneratorResponse__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse, global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Builder> internal__static_google_protobuf_compiler_CodeGeneratorResponse__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_google_protobuf_compiler_CodeGeneratorResponse_File__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File, global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File.Builder> internal__static_google_protobuf_compiler_CodeGeneratorResponse_File__FieldAccessorTable;
+    #endregion
+    #region Descriptor
+    public static pbd::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbd::FileDescriptor descriptor;
+
+    static Plugin() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CiVnb29nbGUvcHJvdG9idWYvY29tcGlsZXIvcGx1Z2luLnByb3RvEhhnb29n",
+            "bGUucHJvdG9idWYuY29tcGlsZXIaIGdvb2dsZS9wcm90b2J1Zi9kZXNjcmlw",
+            "dG9yLnByb3RvIn0KFENvZGVHZW5lcmF0b3JSZXF1ZXN0EhgKEGZpbGVfdG9f",
+            "Z2VuZXJhdGUYASADKAkSEQoJcGFyYW1ldGVyGAIgASgJEjgKCnByb3RvX2Zp",
+            "bGUYDyADKAsyJC5nb29nbGUucHJvdG9idWYuRmlsZURlc2NyaXB0b3JQcm90",
+            "byKqAQoVQ29kZUdlbmVyYXRvclJlc3BvbnNlEg0KBWVycm9yGAEgASgJEkIK",
+            "BGZpbGUYDyADKAsyNC5nb29nbGUucHJvdG9idWYuY29tcGlsZXIuQ29kZUdl",
+            "bmVyYXRvclJlc3BvbnNlLkZpbGUaPgoERmlsZRIMCgRuYW1lGAEgASgJEhcK",
+            "D2luc2VydGlvbl9wb2ludBgCIAEoCRIPCgdjb250ZW50GA8gASgJQiwKHGNv",
+          "bS5nb29nbGUucHJvdG9idWYuY29tcGlsZXJCDFBsdWdpblByb3Rvcw=="));
+      pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
+        descriptor = root;
+        internal__static_google_protobuf_compiler_CodeGeneratorRequest__Descriptor = Descriptor.MessageTypes[0];
+        internal__static_google_protobuf_compiler_CodeGeneratorRequest__FieldAccessorTable =
+            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorRequest, global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorRequest.Builder>(internal__static_google_protobuf_compiler_CodeGeneratorRequest__Descriptor,
+                new string[] { "FileToGenerate", "Parameter", "ProtoFile", });
+        internal__static_google_protobuf_compiler_CodeGeneratorResponse__Descriptor = Descriptor.MessageTypes[1];
+        internal__static_google_protobuf_compiler_CodeGeneratorResponse__FieldAccessorTable =
+            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse, global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Builder>(internal__static_google_protobuf_compiler_CodeGeneratorResponse__Descriptor,
+                new string[] { "Error", "File", });
+        internal__static_google_protobuf_compiler_CodeGeneratorResponse_File__Descriptor = internal__static_google_protobuf_compiler_CodeGeneratorResponse__Descriptor.NestedTypes[0];
+        internal__static_google_protobuf_compiler_CodeGeneratorResponse_File__FieldAccessorTable =
+            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File, global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File.Builder>(internal__static_google_protobuf_compiler_CodeGeneratorResponse_File__Descriptor,
+                new string[] { "Name", "InsertionPoint", "Content", });
+        return null;
+      };
+      pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
+          new pbd::FileDescriptor[] {
+          global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor,
+          }, assigner);
+    }
+    #endregion
+
+  }
+  #region Messages
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public sealed partial class CodeGeneratorRequest : pb::GeneratedMessage<CodeGeneratorRequest, CodeGeneratorRequest.Builder> {
+    private CodeGeneratorRequest() { }
+    private static readonly CodeGeneratorRequest defaultInstance = new CodeGeneratorRequest().MakeReadOnly();
+    private static readonly string[] _codeGeneratorRequestFieldNames = new string[] { "file_to_generate", "parameter", "proto_file" };
+    private static readonly uint[] _codeGeneratorRequestFieldTags = new uint[] { 10, 18, 122 };
+    public static CodeGeneratorRequest DefaultInstance {
+      get { return defaultInstance; }
+    }
+
+    public override CodeGeneratorRequest DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+
+    protected override CodeGeneratorRequest ThisMessage {
+      get { return this; }
+    }
+
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::Google.ProtocolBuffers.Compiler.PluginProto.Plugin.internal__static_google_protobuf_compiler_CodeGeneratorRequest__Descriptor; }
+    }
+
+    protected override pb::FieldAccess.FieldAccessorTable<CodeGeneratorRequest, CodeGeneratorRequest.Builder> InternalFieldAccessors {
+      get { return global::Google.ProtocolBuffers.Compiler.PluginProto.Plugin.internal__static_google_protobuf_compiler_CodeGeneratorRequest__FieldAccessorTable; }
+    }
+
+    public const int FileToGenerateFieldNumber = 1;
+    private pbc::PopsicleList<string> fileToGenerate_ = new pbc::PopsicleList<string>();
+    public scg::IList<string> FileToGenerateList {
+      get { return pbc::Lists.AsReadOnly(fileToGenerate_); }
+    }
+    public int FileToGenerateCount {
+      get { return fileToGenerate_.Count; }
+    }
+    public string GetFileToGenerate(int index) {
+      return fileToGenerate_[index];
+    }
+
+    public const int ParameterFieldNumber = 2;
+    private bool hasParameter;
+    private string parameter_ = "";
+    public bool HasParameter {
+      get { return hasParameter; }
+    }
+    public string Parameter {
+      get { return parameter_; }
+    }
+
+    public const int ProtoFileFieldNumber = 15;
+    private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto> protoFile_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto>();
+    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto> ProtoFileList {
+      get { return protoFile_; }
+    }
+    public int ProtoFileCount {
+      get { return protoFile_.Count; }
+    }
+    public global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto GetProtoFile(int index) {
+      return protoFile_[index];
+    }
+
+    public override bool IsInitialized {
+      get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto element in ProtoFileList) {
+          if (!element.IsInitialized) return false;
+        }
+        return true;
+      }
+    }
+
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _codeGeneratorRequestFieldNames;
+      if (fileToGenerate_.Count > 0) {
+        output.WriteStringArray(1, field_names[0], fileToGenerate_);
+      }
+      if (hasParameter) {
+        output.WriteString(2, field_names[1], Parameter);
+      }
+      if (protoFile_.Count > 0) {
+        output.WriteMessageArray(15, field_names[2], protoFile_);
+      }
+      UnknownFields.WriteTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        {
+          int dataSize = 0;
+          foreach (string element in FileToGenerateList) {
+            dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+          }
+          size += dataSize;
+          size += 1 * fileToGenerate_.Count;
+        }
+        if (hasParameter) {
+          size += pb::CodedOutputStream.ComputeStringSize(2, Parameter);
+        }
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto element in ProtoFileList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(15, element);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+
+    public static CodeGeneratorRequest ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static CodeGeneratorRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static CodeGeneratorRequest ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static CodeGeneratorRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static CodeGeneratorRequest ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static CodeGeneratorRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static CodeGeneratorRequest ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static CodeGeneratorRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static CodeGeneratorRequest ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static CodeGeneratorRequest ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private CodeGeneratorRequest MakeReadOnly() {
+      fileToGenerate_.MakeReadOnly();
+      protoFile_.MakeReadOnly();
+      return this;
+    }
+
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(CodeGeneratorRequest prototype) {
+      return new Builder(prototype);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public sealed partial class Builder : pb::GeneratedBuilder<CodeGeneratorRequest, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(CodeGeneratorRequest cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+
+      private bool resultIsReadOnly;
+      private CodeGeneratorRequest result;
+
+      private CodeGeneratorRequest PrepareBuilder() {
+        if (resultIsReadOnly) {
+          CodeGeneratorRequest original = result;
+          result = new CodeGeneratorRequest();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+
+      protected override CodeGeneratorRequest MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorRequest.Descriptor; }
+      }
+
+      public override CodeGeneratorRequest DefaultInstanceForType {
+        get { return global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorRequest.DefaultInstance; }
+      }
+
+      public override CodeGeneratorRequest BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is CodeGeneratorRequest) {
+          return MergeFrom((CodeGeneratorRequest) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+
+      public override Builder MergeFrom(CodeGeneratorRequest other) {
+        if (other == global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorRequest.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.fileToGenerate_.Count != 0) {
+          result.fileToGenerate_.Add(other.fileToGenerate_);
+        }
+        if (other.HasParameter) {
+          Parameter = other.Parameter;
+        }
+        if (other.protoFile_.Count != 0) {
+          result.protoFile_.Add(other.protoFile_);
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_codeGeneratorRequestFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _codeGeneratorRequestFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 10: {
+              input.ReadStringArray(tag, field_name, result.fileToGenerate_);
+              break;
+            }
+            case 18: {
+              result.hasParameter = input.ReadString(ref result.parameter_);
+              break;
+            }
+            case 122: {
+              input.ReadMessageArray(tag, field_name, result.protoFile_, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.DefaultInstance, extensionRegistry);
+              break;
+            }
+          }
+        }
+
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+
+
+      public pbc::IPopsicleList<string> FileToGenerateList {
+        get { return PrepareBuilder().fileToGenerate_; }
+      }
+      public int FileToGenerateCount {
+        get { return result.FileToGenerateCount; }
+      }
+      public string GetFileToGenerate(int index) {
+        return result.GetFileToGenerate(index);
+      }
+      public Builder SetFileToGenerate(int index, string value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.fileToGenerate_[index] = value;
+        return this;
+      }
+      public Builder AddFileToGenerate(string value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.fileToGenerate_.Add(value);
+        return this;
+      }
+      public Builder AddRangeFileToGenerate(scg::IEnumerable<string> values) {
+        PrepareBuilder();
+        result.fileToGenerate_.Add(values);
+        return this;
+      }
+      public Builder ClearFileToGenerate() {
+        PrepareBuilder();
+        result.fileToGenerate_.Clear();
+        return this;
+      }
+
+      public bool HasParameter {
+        get { return result.hasParameter; }
+      }
+      public string Parameter {
+        get { return result.Parameter; }
+        set { SetParameter(value); }
+      }
+      public Builder SetParameter(string value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasParameter = true;
+        result.parameter_ = value;
+        return this;
+      }
+      public Builder ClearParameter() {
+        PrepareBuilder();
+        result.hasParameter = false;
+        result.parameter_ = "";
+        return this;
+      }
+
+      public pbc::IPopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto> ProtoFileList {
+        get { return PrepareBuilder().protoFile_; }
+      }
+      public int ProtoFileCount {
+        get { return result.ProtoFileCount; }
+      }
+      public global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto GetProtoFile(int index) {
+        return result.GetProtoFile(index);
+      }
+      public Builder SetProtoFile(int index, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.protoFile_[index] = value;
+        return this;
+      }
+      public Builder SetProtoFile(int index, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.protoFile_[index] = builderForValue.Build();
+        return this;
+      }
+      public Builder AddProtoFile(global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.protoFile_.Add(value);
+        return this;
+      }
+      public Builder AddProtoFile(global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.protoFile_.Add(builderForValue.Build());
+        return this;
+      }
+      public Builder AddRangeProtoFile(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto> values) {
+        PrepareBuilder();
+        result.protoFile_.Add(values);
+        return this;
+      }
+      public Builder ClearProtoFile() {
+        PrepareBuilder();
+        result.protoFile_.Clear();
+        return this;
+      }
+    }
+    static CodeGeneratorRequest() {
+      object.ReferenceEquals(global::Google.ProtocolBuffers.Compiler.PluginProto.Plugin.Descriptor, null);
+    }
+  }
+
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  public sealed partial class CodeGeneratorResponse : pb::GeneratedMessage<CodeGeneratorResponse, CodeGeneratorResponse.Builder> {
+    private CodeGeneratorResponse() { }
+    private static readonly CodeGeneratorResponse defaultInstance = new CodeGeneratorResponse().MakeReadOnly();
+    private static readonly string[] _codeGeneratorResponseFieldNames = new string[] { "error", "file" };
+    private static readonly uint[] _codeGeneratorResponseFieldTags = new uint[] { 10, 122 };
+    public static CodeGeneratorResponse DefaultInstance {
+      get { return defaultInstance; }
+    }
+
+    public override CodeGeneratorResponse DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+
+    protected override CodeGeneratorResponse ThisMessage {
+      get { return this; }
+    }
+
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::Google.ProtocolBuffers.Compiler.PluginProto.Plugin.internal__static_google_protobuf_compiler_CodeGeneratorResponse__Descriptor; }
+    }
+
+    protected override pb::FieldAccess.FieldAccessorTable<CodeGeneratorResponse, CodeGeneratorResponse.Builder> InternalFieldAccessors {
+      get { return global::Google.ProtocolBuffers.Compiler.PluginProto.Plugin.internal__static_google_protobuf_compiler_CodeGeneratorResponse__FieldAccessorTable; }
+    }
+
+    #region Nested types
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public static partial class Types {
+      [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+      public sealed partial class File : pb::GeneratedMessage<File, File.Builder> {
+        private File() { }
+        private static readonly File defaultInstance = new File().MakeReadOnly();
+        private static readonly string[] _fileFieldNames = new string[] { "content", "insertion_point", "name" };
+        private static readonly uint[] _fileFieldTags = new uint[] { 122, 18, 10 };
+        public static File DefaultInstance {
+          get { return defaultInstance; }
+        }
+
+        public override File DefaultInstanceForType {
+          get { return DefaultInstance; }
+        }
+
+        protected override File ThisMessage {
+          get { return this; }
+        }
+
+        public static pbd::MessageDescriptor Descriptor {
+          get { return global::Google.ProtocolBuffers.Compiler.PluginProto.Plugin.internal__static_google_protobuf_compiler_CodeGeneratorResponse_File__Descriptor; }
+        }
+
+        protected override pb::FieldAccess.FieldAccessorTable<File, File.Builder> InternalFieldAccessors {
+          get { return global::Google.ProtocolBuffers.Compiler.PluginProto.Plugin.internal__static_google_protobuf_compiler_CodeGeneratorResponse_File__FieldAccessorTable; }
+        }
+
+        public const int NameFieldNumber = 1;
+        private bool hasName;
+        private string name_ = "";
+        public bool HasName {
+          get { return hasName; }
+        }
+        public string Name {
+          get { return name_; }
+        }
+
+        public const int InsertionPointFieldNumber = 2;
+        private bool hasInsertionPoint;
+        private string insertionPoint_ = "";
+        public bool HasInsertionPoint {
+          get { return hasInsertionPoint; }
+        }
+        public string InsertionPoint {
+          get { return insertionPoint_; }
+        }
+
+        public const int ContentFieldNumber = 15;
+        private bool hasContent;
+        private string content_ = "";
+        public bool HasContent {
+          get { return hasContent; }
+        }
+        public string Content {
+          get { return content_; }
+        }
+
+        public override bool IsInitialized {
+          get {
+            return true;
+          }
+        }
+
+        public override void WriteTo(pb::ICodedOutputStream output) {
+          int size = SerializedSize;
+          string[] field_names = _fileFieldNames;
+          if (hasName) {
+            output.WriteString(1, field_names[2], Name);
+          }
+          if (hasInsertionPoint) {
+            output.WriteString(2, field_names[1], InsertionPoint);
+          }
+          if (hasContent) {
+            output.WriteString(15, field_names[0], Content);
+          }
+          UnknownFields.WriteTo(output);
+        }
+
+        private int memoizedSerializedSize = -1;
+        public override int SerializedSize {
+          get {
+            int size = memoizedSerializedSize;
+            if (size != -1) return size;
+
+            size = 0;
+            if (hasName) {
+              size += pb::CodedOutputStream.ComputeStringSize(1, Name);
+            }
+            if (hasInsertionPoint) {
+              size += pb::CodedOutputStream.ComputeStringSize(2, InsertionPoint);
+            }
+            if (hasContent) {
+              size += pb::CodedOutputStream.ComputeStringSize(15, Content);
+            }
+            size += UnknownFields.SerializedSize;
+            memoizedSerializedSize = size;
+            return size;
+          }
+        }
+
+        public static File ParseFrom(pb::ByteString data) {
+          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+        }
+        public static File ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+        }
+        public static File ParseFrom(byte[] data) {
+          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+        }
+        public static File ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+        }
+        public static File ParseFrom(global::System.IO.Stream input) {
+          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+        }
+        public static File ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+        }
+        public static File ParseDelimitedFrom(global::System.IO.Stream input) {
+          return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+        }
+        public static File ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+          return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+        }
+        public static File ParseFrom(pb::ICodedInputStream input) {
+          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+        }
+        public static File ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+        }
+        private File MakeReadOnly() {
+          return this;
+        }
+
+        public static Builder CreateBuilder() { return new Builder(); }
+        public override Builder ToBuilder() { return CreateBuilder(this); }
+        public override Builder CreateBuilderForType() { return new Builder(); }
+        public static Builder CreateBuilder(File prototype) {
+          return new Builder(prototype);
+        }
+
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        public sealed partial class Builder : pb::GeneratedBuilder<File, Builder> {
+          protected override Builder ThisBuilder {
+            get { return this; }
+          }
+          public Builder() {
+            result = DefaultInstance;
+            resultIsReadOnly = true;
+          }
+          internal Builder(File cloneFrom) {
+            result = cloneFrom;
+            resultIsReadOnly = true;
+          }
+
+          private bool resultIsReadOnly;
+          private File result;
+
+          private File PrepareBuilder() {
+            if (resultIsReadOnly) {
+              File original = result;
+              result = new File();
+              resultIsReadOnly = false;
+              MergeFrom(original);
+            }
+            return result;
+          }
+
+          public override bool IsInitialized {
+            get { return result.IsInitialized; }
+          }
+
+          protected override File MessageBeingBuilt {
+            get { return PrepareBuilder(); }
+          }
+
+          public override Builder Clear() {
+            result = DefaultInstance;
+            resultIsReadOnly = true;
+            return this;
+          }
+
+          public override Builder Clone() {
+            if (resultIsReadOnly) {
+              return new Builder(result);
+            } else {
+              return new Builder().MergeFrom(result);
+            }
+          }
+
+          public override pbd::MessageDescriptor DescriptorForType {
+            get { return global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File.Descriptor; }
+          }
+
+          public override File DefaultInstanceForType {
+            get { return global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File.DefaultInstance; }
+          }
+
+          public override File BuildPartial() {
+            if (resultIsReadOnly) {
+              return result;
+            }
+            resultIsReadOnly = true;
+            return result.MakeReadOnly();
+          }
+
+          public override Builder MergeFrom(pb::IMessage other) {
+            if (other is File) {
+              return MergeFrom((File) other);
+            } else {
+              base.MergeFrom(other);
+              return this;
+            }
+          }
+
+          public override Builder MergeFrom(File other) {
+            if (other == global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File.DefaultInstance) return this;
+            PrepareBuilder();
+            if (other.HasName) {
+              Name = other.Name;
+            }
+            if (other.HasInsertionPoint) {
+              InsertionPoint = other.InsertionPoint;
+            }
+            if (other.HasContent) {
+              Content = other.Content;
+            }
+            this.MergeUnknownFields(other.UnknownFields);
+            return this;
+          }
+
+          public override Builder MergeFrom(pb::ICodedInputStream input) {
+            return MergeFrom(input, pb::ExtensionRegistry.Empty);
+          }
+
+          public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+            PrepareBuilder();
+            pb::UnknownFieldSet.Builder unknownFields = null;
+            uint tag;
+            string field_name;
+            while (input.ReadTag(out tag, out field_name)) {
+              if(tag == 0 && field_name != null) {
+                int field_ordinal = global::System.Array.BinarySearch(_fileFieldNames, field_name, global::System.StringComparer.Ordinal);
+                if(field_ordinal >= 0)
+                  tag = _fileFieldTags[field_ordinal];
+                else {
+                  if (unknownFields == null) {
+                    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+                  }
+                  ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+                  continue;
+                }
+              }
+              switch (tag) {
+                case 0: {
+                  throw pb::InvalidProtocolBufferException.InvalidTag();
+                }
+                default: {
+                  if (pb::WireFormat.IsEndGroupTag(tag)) {
+                    if (unknownFields != null) {
+                      this.UnknownFields = unknownFields.Build();
+                    }
+                    return this;
+                  }
+                  if (unknownFields == null) {
+                    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+                  }
+                  ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+                  break;
+                }
+                case 10: {
+                  result.hasName = input.ReadString(ref result.name_);
+                  break;
+                }
+                case 18: {
+                  result.hasInsertionPoint = input.ReadString(ref result.insertionPoint_);
+                  break;
+                }
+                case 122: {
+                  result.hasContent = input.ReadString(ref result.content_);
+                  break;
+                }
+              }
+            }
+
+            if (unknownFields != null) {
+              this.UnknownFields = unknownFields.Build();
+            }
+            return this;
+          }
+
+
+          public bool HasName {
+            get { return result.hasName; }
+          }
+          public string Name {
+            get { return result.Name; }
+            set { SetName(value); }
+          }
+          public Builder SetName(string value) {
+            pb::ThrowHelper.ThrowIfNull(value, "value");
+            PrepareBuilder();
+            result.hasName = true;
+            result.name_ = value;
+            return this;
+          }
+          public Builder ClearName() {
+            PrepareBuilder();
+            result.hasName = false;
+            result.name_ = "";
+            return this;
+          }
+
+          public bool HasInsertionPoint {
+            get { return result.hasInsertionPoint; }
+          }
+          public string InsertionPoint {
+            get { return result.InsertionPoint; }
+            set { SetInsertionPoint(value); }
+          }
+          public Builder SetInsertionPoint(string value) {
+            pb::ThrowHelper.ThrowIfNull(value, "value");
+            PrepareBuilder();
+            result.hasInsertionPoint = true;
+            result.insertionPoint_ = value;
+            return this;
+          }
+          public Builder ClearInsertionPoint() {
+            PrepareBuilder();
+            result.hasInsertionPoint = false;
+            result.insertionPoint_ = "";
+            return this;
+          }
+
+          public bool HasContent {
+            get { return result.hasContent; }
+          }
+          public string Content {
+            get { return result.Content; }
+            set { SetContent(value); }
+          }
+          public Builder SetContent(string value) {
+            pb::ThrowHelper.ThrowIfNull(value, "value");
+            PrepareBuilder();
+            result.hasContent = true;
+            result.content_ = value;
+            return this;
+          }
+          public Builder ClearContent() {
+            PrepareBuilder();
+            result.hasContent = false;
+            result.content_ = "";
+            return this;
+          }
+        }
+        static File() {
+          object.ReferenceEquals(global::Google.ProtocolBuffers.Compiler.PluginProto.Plugin.Descriptor, null);
+        }
+      }
+
+    }
+    #endregion
+
+    public const int ErrorFieldNumber = 1;
+    private bool hasError;
+    private string error_ = "";
+    public bool HasError {
+      get { return hasError; }
+    }
+    public string Error {
+      get { return error_; }
+    }
+
+    public const int FileFieldNumber = 15;
+    private pbc::PopsicleList<global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File> file_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File>();
+    public scg::IList<global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File> FileList {
+      get { return file_; }
+    }
+    public int FileCount {
+      get { return file_.Count; }
+    }
+    public global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File GetFile(int index) {
+      return file_[index];
+    }
+
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _codeGeneratorResponseFieldNames;
+      if (hasError) {
+        output.WriteString(1, field_names[0], Error);
+      }
+      if (file_.Count > 0) {
+        output.WriteMessageArray(15, field_names[1], file_);
+      }
+      UnknownFields.WriteTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        if (hasError) {
+          size += pb::CodedOutputStream.ComputeStringSize(1, Error);
+        }
+        foreach (global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File element in FileList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(15, element);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+
+    public static CodeGeneratorResponse ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static CodeGeneratorResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static CodeGeneratorResponse ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static CodeGeneratorResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static CodeGeneratorResponse ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static CodeGeneratorResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static CodeGeneratorResponse ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static CodeGeneratorResponse ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static CodeGeneratorResponse ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static CodeGeneratorResponse ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private CodeGeneratorResponse MakeReadOnly() {
+      file_.MakeReadOnly();
+      return this;
+    }
+
+    public static Builder CreateBuilder() { return new Builder(); }
+    public override Builder ToBuilder() { return CreateBuilder(this); }
+    public override Builder CreateBuilderForType() { return new Builder(); }
+    public static Builder CreateBuilder(CodeGeneratorResponse prototype) {
+      return new Builder(prototype);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    public sealed partial class Builder : pb::GeneratedBuilder<CodeGeneratorResponse, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(CodeGeneratorResponse cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+
+      private bool resultIsReadOnly;
+      private CodeGeneratorResponse result;
+
+      private CodeGeneratorResponse PrepareBuilder() {
+        if (resultIsReadOnly) {
+          CodeGeneratorResponse original = result;
+          result = new CodeGeneratorResponse();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+
+      protected override CodeGeneratorResponse MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Descriptor; }
+      }
+
+      public override CodeGeneratorResponse DefaultInstanceForType {
+        get { return global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.DefaultInstance; }
+      }
+
+      public override CodeGeneratorResponse BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is CodeGeneratorResponse) {
+          return MergeFrom((CodeGeneratorResponse) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+
+      public override Builder MergeFrom(CodeGeneratorResponse other) {
+        if (other == global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasError) {
+          Error = other.Error;
+        }
+        if (other.file_.Count != 0) {
+          result.file_.Add(other.file_);
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_codeGeneratorResponseFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _codeGeneratorResponseFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                if (unknownFields != null) {
+                  this.UnknownFields = unknownFields.Build();
+                }
+                return this;
+              }
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 10: {
+              result.hasError = input.ReadString(ref result.error_);
+              break;
+            }
+            case 122: {
+              input.ReadMessageArray(tag, field_name, result.file_, global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File.DefaultInstance, extensionRegistry);
+              break;
+            }
+          }
+        }
+
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+
+
+      public bool HasError {
+        get { return result.hasError; }
+      }
+      public string Error {
+        get { return result.Error; }
+        set { SetError(value); }
+      }
+      public Builder SetError(string value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasError = true;
+        result.error_ = value;
+        return this;
+      }
+      public Builder ClearError() {
+        PrepareBuilder();
+        result.hasError = false;
+        result.error_ = "";
+        return this;
+      }
+
+      public pbc::IPopsicleList<global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File> FileList {
+        get { return PrepareBuilder().file_; }
+      }
+      public int FileCount {
+        get { return result.FileCount; }
+      }
+      public global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File GetFile(int index) {
+        return result.GetFile(index);
+      }
+      public Builder SetFile(int index, global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.file_[index] = value;
+        return this;
+      }
+      public Builder SetFile(int index, global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.file_[index] = builderForValue.Build();
+        return this;
+      }
+      public Builder AddFile(global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.file_.Add(value);
+        return this;
+      }
+      public Builder AddFile(global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.file_.Add(builderForValue.Build());
+        return this;
+      }
+      public Builder AddRangeFile(scg::IEnumerable<global::Google.ProtocolBuffers.Compiler.PluginProto.CodeGeneratorResponse.Types.File> values) {
+        PrepareBuilder();
+        result.file_.Add(values);
+        return this;
+      }
+      public Builder ClearFile() {
+        PrepareBuilder();
+        result.file_.Clear();
+        return this;
+      }
+    }
+    static CodeGeneratorResponse() {
+      object.ReferenceEquals(global::Google.ProtocolBuffers.Compiler.PluginProto.Plugin.Descriptor, null);
+    }
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/src/ProtoGen/Program.cs b/src/ProtoGen/Program.cs
index 4bd6c463..b11d32e0 100644
--- a/src/ProtoGen/Program.cs
+++ b/src/ProtoGen/Program.cs
@@ -35,7 +35,9 @@
 #endregion
 
 using System;
+using System.IO;
 using System.Collections.Generic;
+using Google.ProtocolBuffers.Compiler.PluginProto;
 using Google.ProtocolBuffers.DescriptorProtos;
 
 namespace Google.ProtocolBuffers.ProtoGen
@@ -62,8 +64,33 @@ namespace Google.ProtocolBuffers.ProtoGen
                     return 1;
                 }
 
+                var request = new CodeGeneratorRequest.Builder();
+                foreach (string inputFile in options.InputFiles)
+                {
+                    ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance();
+                    CSharpOptions.RegisterAllExtensions(extensionRegistry);
+                    using (Stream inputStream = File.OpenRead(inputFile))
+                    {
+                        var fileSet = FileDescriptorSet.ParseFrom(inputStream, extensionRegistry);
+                        foreach (var fileProto in fileSet.FileList)
+                        {
+                            request.AddFileToGenerate(fileProto.Name);
+                            request.AddProtoFile(fileProto);
+                        }
+                    }
+                }
+
                 Generator generator = Generator.CreateGenerator(options);
-                generator.Generate();
+                var response = new CodeGeneratorResponse.Builder();
+                generator.Generate(request.Build(), response);
+                if (response.HasError)
+                {
+                    throw new Exception(response.Error);
+                }
+                foreach (var file in response.FileList)
+                {
+                    File.WriteAllText(file.Name, file.Content);
+                }
                 return 0;
             }
             catch (Exception e)
diff --git a/src/ProtoGen/ProtoGen.csproj b/src/ProtoGen/ProtoGen.csproj
index aaab3993..2de44aec 100644
--- a/src/ProtoGen/ProtoGen.csproj
+++ b/src/ProtoGen/ProtoGen.csproj
@@ -59,6 +59,7 @@
     <Compile Include="ISourceGenerator.cs" />
     <Compile Include="MessageFieldGenerator.cs" />
     <Compile Include="MessageGenerator.cs" />
+    <Compile Include="PluginProtoFile.cs" />
     <Compile Include="PrimitiveFieldGenerator.cs" />
     <Compile Include="ProgramPreprocess.cs" />
     <Compile Include="RepeatedEnumFieldGenerator.cs" />
diff --git a/src/ProtoGen/ProtocGenCs.cs b/src/ProtoGen/ProtocGenCs.cs
new file mode 100644
index 00000000..29264200
--- /dev/null
+++ b/src/ProtoGen/ProtocGenCs.cs
@@ -0,0 +1,76 @@
+using Google.ProtocolBuffers.Compiler.PluginProto;
+using Google.ProtocolBuffers.DescriptorProtos;
+using System;
+using System.Collections.Generic;
+
+// Usage example:
+//   protoc.exe
+//     --plugin=path\to\protoc-gen-cs.exe
+//     --cs_out="-generated_code_attributes=true umbrella_namespace=TutorialProto :."
+//     --proto_path=.\protos\
+//     protos\tutorial\addressbook.proto
+
+namespace Google.ProtocolBuffers.ProtoGen
+{
+    public static class ProtocGenCs
+    {
+        internal static void Run(CodeGeneratorRequest request, CodeGeneratorResponse.Builder response)
+        {
+            var arguments = new List<string>();
+            foreach (var arg in request.Parameter.Split(' '))
+            {
+                var timmedArg = (arg ?? "").Trim();
+                if (!string.IsNullOrEmpty(timmedArg))
+                {
+                    arguments.Add(timmedArg);
+                }
+            }
+            // Adding fake input file to make TryValidate happy.
+            arguments.Add(System.Reflection.Assembly.GetExecutingAssembly().Location);
+
+            GeneratorOptions options = new GeneratorOptions
+            {
+                Arguments = arguments
+            };
+            IList<string> validationFailures;
+            if (!options.TryValidate(out validationFailures))
+            {
+                response.Error += new InvalidOptionsException(validationFailures).Message;
+                return;
+            }
+
+            Generator generator = Generator.CreateGenerator(options);
+            generator.Generate(request, response);
+        }
+
+        public static int Main(string[] args)
+        {
+            // Hack to make sure everything's initialized
+            DescriptorProtoFile.Descriptor.ToString();
+            ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance();
+            CSharpOptions.RegisterAllExtensions(extensionRegistry);
+
+            CodeGeneratorRequest request;
+            var response = new CodeGeneratorResponse.Builder();
+            try
+            {
+                using (var input = Console.OpenStandardInput())
+                {
+                    request = CodeGeneratorRequest.ParseFrom(input, extensionRegistry);
+                }
+                Run(request, response);
+            }
+            catch (Exception e)
+            {
+                response.Error += e.ToString();
+            }
+
+            using (var output = Console.OpenStandardOutput())
+            {
+                response.Build().WriteTo(output);
+                output.Flush();
+            }
+            return 0;
+        }
+    }
+}
diff --git a/src/ProtoGen/protoc-gen-cs.csproj b/src/ProtoGen/protoc-gen-cs.csproj
new file mode 100644
index 00000000..fdc88cc2
--- /dev/null
+++ b/src/ProtoGen/protoc-gen-cs.csproj
@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <EnvironmentFlavor>CLIENTPROFILE</EnvironmentFlavor>
+    <EnvironmentTemplate>NET35</EnvironmentTemplate>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{250ADE34-82FD-4BAE-86D5-985FBE589C4B}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Google.ProtocolBuffers.ProtoGen</RootNamespace>
+    <AssemblyName>protoc-gen-cs</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\..\keys\Google.ProtocolBuffers.snk</AssemblyOriginatorKeyFile>
+    <StartupObject>Google.ProtocolBuffers.ProtoGen.ProtocGenCs</StartupObject>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\NET35\Debug</OutputPath>
+    <IntermediateOutputPath>obj\NET35\Debug\</IntermediateOutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <NoStdLib>true</NoStdLib>
+    <GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\NET35\Release</OutputPath>
+    <IntermediateOutputPath>obj\NET35\Release\</IntermediateOutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <NoStdLib>true</NoStdLib>
+    <GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="mscorlib" />
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="DescriptorUtil.cs" />
+    <Compile Include="EnumFieldGenerator.cs" />
+    <Compile Include="EnumGenerator.cs" />
+    <Compile Include="ExtensionGenerator.cs" />
+    <Compile Include="FieldGeneratorBase.cs" />
+    <Compile Include="IFieldSourceGenerator.cs" />
+    <Compile Include="ISourceGenerator.cs" />
+    <Compile Include="MessageFieldGenerator.cs" />
+    <Compile Include="MessageGenerator.cs" />
+    <Compile Include="PluginProtoFile.cs" />
+    <Compile Include="PrimitiveFieldGenerator.cs" />
+    <Compile Include="ProtocGenCs.cs" />
+    <Compile Include="RepeatedEnumFieldGenerator.cs" />
+    <Compile Include="RepeatedMessageFieldGenerator.cs" />
+    <Compile Include="RepeatedPrimitiveFieldGenerator.cs" />
+    <Compile Include="ServiceGenerator.cs" />
+    <Compile Include="DependencyResolutionException.cs" />
+    <Compile Include="Generator.cs" />
+    <Compile Include="GeneratorOptions.cs" />
+    <Compile Include="Helpers.cs" />
+    <Compile Include="InvalidOptionsException.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ServiceInterfaceGenerator.cs" />
+    <Compile Include="SourceGeneratorBase.cs" />
+    <Compile Include="SourceGenerators.cs" />
+    <Compile Include="UmbrellaClassGenerator.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ProtocolBuffers.Serialization\ProtocolBuffers.Serialization.csproj">
+      <Project>{231391af-449c-4a39-986c-ad7f270f4750}</Project>
+      <Name>ProtocolBuffers.Serialization</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj">
+      <Project>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</Project>
+      <Name>ProtocolBuffers</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
+\ No newline at end of file
author	Jon Skeet <skeet@pobox.com>	2014-08-02 21:57:54 +0100
committer	Jon Skeet <skeet@pobox.com>	2014-08-02 21:57:54 +0100
commit	92d6214e0f76cc92f35f3a44aa89e0b0e60df5e8 (patch)
tree	c0f2a5106c67a90509e176837e9b29b2426fba4c /src/ProtoGen
parent	fd6c129298e1302c4a96c4d4b56b83f2dcc1838c (diff)
download	protobuf-92d6214e0f76cc92f35f3a44aa89e0b0e60df5e8.tar.gz protobuf-92d6214e0f76cc92f35f3a44aa89e0b0e60df5e8.tar.bz2 protobuf-92d6214e0f76cc92f35f3a44aa89e0b0e60df5e8.zip