Update //third_party/protobuf to version 3.

third_party/protobuf/src/google/protobuf/compiler/python/python_generator.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// http://code.google.com/p/protobuf/
+// 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.
 
+//#PY25 compatible generated code for GAE.
+// Copyright 2007 Google Inc. All Rights Reserved.
 // Author: robinson@google.com (Will Robinson)
 //
 // This module outputs pure-Python protocol message classes that will
 // largely be constructed at runtime via the metaclass in reflection.py.
 // In other words, our job is basically to output a Python equivalent
 // of the C++ *Descriptor objects, and fix up all circular references
 // within these objects.
 //
 // Note that the runtime performance of protocol message classes created in
 // this way is expected to be lousy.  The plan is to create an alternate
 // generator that outputs a Python/C extension module that lets
 // performance-minded Python code leverage the fast C++ implementation
 // directly.
 
+#include <google/protobuf/stubs/hash.h>
 #include <limits>
 #include <map>
+#include <memory>
+#ifndef _SHARED_PTR_H
+#include <google/protobuf/stubs/shared_ptr.h>
+#endif
+#include <string>
 #include <utility>
-#include <string>
 #include <vector>
 
 #include <google/protobuf/compiler/python/python_generator.h>
 #include <google/protobuf/descriptor.pb.h>
 
+#include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/stubs/stringprintf.h>
 #include <google/protobuf/io/printer.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/io/zero_copy_stream.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/stubs/substitute.h>
 
 namespace google {
 namespace protobuf {
@@ skipping 14 matching lines @@
 
 // Returns the Python module name expected for a given .proto filename.
 string ModuleName(const string& filename) {
   string basename = StripProto(filename);
   StripString(&basename, "-", '_');
   StripString(&basename, "/", '.');
   return basename + "_pb2";
 }
 
 
+// Returns the alias we assign to the module of the given .proto filename
+// when importing. See testPackageInitializationImport in
+// google/protobuf/python/reflection_test.py
+// to see why we need the alias.
+string ModuleAlias(const string& filename) {
+  string module_name = ModuleName(filename);
+  // We can't have dots in the module name, so we replace each with _dot_.
+  // But that could lead to a collision between a.b and a_dot_b, so we also
+  // duplicate each underscore.
+  GlobalReplaceSubstring("_", "__", &module_name);
+  GlobalReplaceSubstring(".", "_dot_", &module_name);
+  return module_name;
+}
+
+
+// Returns an import statement of form "from X.Y.Z import T" for the given
+// .proto filename.
+string ModuleImportStatement(const string& filename) {
+  string module_name = ModuleName(filename);
+  int last_dot_pos = module_name.rfind('.');
+  if (last_dot_pos == string::npos) {
+    // NOTE(petya): this is not tested as it would require a protocol buffer
+    // outside of any package, and I don't think that is easily achievable.
+    return "import " + module_name;
+  } else {
+    return "from " + module_name.substr(0, last_dot_pos) + " import " +
+        module_name.substr(last_dot_pos + 1);
+  }
+}
+
+
 // Returns the name of all containing types for descriptor,
 // in order from outermost to innermost, followed by descriptor's
 // own name.  Each name is separated by |separator|.
 template <typename DescriptorT>
 string NamePrefixedWithNestedTypes(const DescriptorT& descriptor,
                                    const string& separator) {
   string name = descriptor.name();
   for (const Descriptor* current = descriptor.containing_type();
        current != NULL; current = current->containing_type()) {
     name = current->name() + separator + name;
@@ skipping 23 matching lines @@
 
 
 // Prints the common boilerplate needed at the top of every .py
 // file output by this generator.
 void PrintTopBoilerplate(
     io::Printer* printer, const FileDescriptor* file, bool descriptor_proto) {
   // TODO(robinson): Allow parameterization of Python version?
   printer->Print(
       "# Generated by the protocol buffer compiler.  DO NOT EDIT!\n"
       "# source: $filename$\n"
+      "\nimport sys\n_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))"  //##PY25
       "\n",
       "filename", file->name());
   if (HasTopLevelEnums(file)) {
     printer->Print(
         "from google.protobuf.internal import enum_type_wrapper\n");
   }
   printer->Print(
       "from google.protobuf import descriptor as _descriptor\n"
       "from google.protobuf import message as _message\n"
       "from google.protobuf import reflection as _reflection\n"
-      );
+      "from google.protobuf import symbol_database as "
+      "_symbol_database\n");
   if (HasGenericServices(file)) {
     printer->Print(
         "from google.protobuf import service as _service\n"
         "from google.protobuf import service_reflection\n");
   }
 
   // Avoid circular imports if this module is descriptor_pb2.
   if (!descriptor_proto) {
     printer->Print(
         "from google.protobuf import descriptor_pb2\n");
   }
   printer->Print(
-    "# @@protoc_insertion_point(imports)\n");
+      "# @@protoc_insertion_point(imports)\n\n"
+      "_sym_db = _symbol_database.Default()\n");
   printer->Print("\n\n");
 }
 
 
 // Returns a Python literal giving the default value for a field.
 // If the field specifies no explicit default value, we'll return
 // the default default value for the field type (zero for numbers,
 // empty string for strings, empty list for repeated fields, and
 // None for non-repeated, composite fields).
 //
@@ skipping 45 matching lines @@
         return "(1e10000 * 0)";
       } else {
         return SimpleFtoa(value);
       }
     }
     case FieldDescriptor::CPPTYPE_BOOL:
       return field.default_value_bool() ? "True" : "False";
     case FieldDescriptor::CPPTYPE_ENUM:
       return SimpleItoa(field.default_value_enum()->number());
     case FieldDescriptor::CPPTYPE_STRING:
-      if (field.type() == FieldDescriptor::TYPE_STRING) {
-        return "unicode(\"" + CEscape(field.default_value_string()) +
-                        "\", \"utf-8\")";
-      } else {
-        return "\"" + CEscape(field.default_value_string()) + "\"";
-      }
-      case FieldDescriptor::CPPTYPE_MESSAGE:
-          return "None";
+//##!PY25      return "b\"" + CEscape(field.default_value_string()) +
+//##!PY25             (field.type() != FieldDescriptor::TYPE_STRING ? "\"" :
+//##!PY25               "\".decode('utf-8')");
+      return "_b(\"" + CEscape(field.default_value_string()) +  //##PY25
+             (field.type() != FieldDescriptor::TYPE_STRING ? "\")" :  //##PY25
+               "\").decode('utf-8')");  //##PY25
+    case FieldDescriptor::CPPTYPE_MESSAGE:
+      return "None";
   }
   // (We could add a default case above but then we wouldn't get the nice
   // compiler warning when a new type is added.)
   GOOGLE_LOG(FATAL) << "Not reached.";
   return "";
 }
 
+string StringifySyntax(FileDescriptor::Syntax syntax) {
+  switch (syntax) {
+    case FileDescriptor::SYNTAX_PROTO2:
+      return "proto2";
+    case FileDescriptor::SYNTAX_PROTO3:
+      return "proto3";
+    case FileDescriptor::SYNTAX_UNKNOWN:
+    default:
+      GOOGLE_LOG(FATAL) << "Unsupported syntax; this generator only supports proto2 "
+                    "and proto3 syntax.";
+      return "";
+  }
+}
 
 
 }  // namespace
 
 
 Generator::Generator() : file_(NULL) {
 }
 
 Generator::~Generator() {
 }
@@ skipping 15 matching lines @@
   string module_name = ModuleName(file->name());
   string filename = module_name;
   StripString(&filename, ".", '/');
   filename += ".py";
 
   FileDescriptorProto fdp;
   file_->CopyTo(&fdp);
   fdp.SerializeToString(&file_descriptor_serialized_);
 
 
-  scoped_ptr<io::ZeroCopyOutputStream> output(context->Open(filename));
+  google::protobuf::scoped_ptr<io::ZeroCopyOutputStream> output(context->Open(filename));
   GOOGLE_CHECK(output.get());
   io::Printer printer(output.get(), '$');
   printer_ = &printer;
 
   PrintTopBoilerplate(printer_, file_, GeneratingDescriptorProto());
   PrintImports();
   PrintFileDescriptor();
   PrintTopLevelEnums();
   PrintTopLevelExtensions();
   PrintAllNestedEnumsInFile();
@@ skipping 15 matching lines @@
 
   printer.Print(
     "# @@protoc_insertion_point(module_scope)\n");
 
   return !printer.failed();
 }
 
 // Prints Python imports for all modules imported by |file|.
 void Generator::PrintImports() const {
   for (int i = 0; i < file_->dependency_count(); ++i) {
-    string module_name = ModuleName(file_->dependency(i)->name());
-    printer_->Print("import $module$\n", "module",
-                    module_name);
+    const string& filename = file_->dependency(i)->name();
+    string import_statement = ModuleImportStatement(filename);
+    string module_alias = ModuleAlias(filename);
+    printer_->Print("$statement$ as $alias$\n", "statement",
+                    import_statement, "alias", module_alias);
+    CopyPublicDependenciesAliases(module_alias, file_->dependency(i));
   }
   printer_->Print("\n");
 
   // Print public imports.
   for (int i = 0; i < file_->public_dependency_count(); ++i) {
     string module_name = ModuleName(file_->public_dependency(i)->name());
     printer_->Print("from $module$ import *\n", "module", module_name);
   }
   printer_->Print("\n");
 }
 
 // Prints the single file descriptor for this file.
 void Generator::PrintFileDescriptor() const {
   map<string, string> m;
   m["descriptor_name"] = kDescriptorKey;
   m["name"] = file_->name();
   m["package"] = file_->package();
+  m["syntax"] = StringifySyntax(file_->syntax());
   const char file_descriptor_template[] =
       "$descriptor_name$ = _descriptor.FileDescriptor(\n"
       "  name='$name$',\n"
-      "  package='$package$',\n";
+      "  package='$package$',\n"
+      "  syntax='$syntax$',\n";
   printer_->Print(m, file_descriptor_template);
   printer_->Indent();
   printer_->Print(
-      "serialized_pb='$value$'",
+//##!PY25      "serialized_pb=b'$value$'\n",
+      "serialized_pb=_b('$value$')\n",  //##PY25
       "value", strings::CHexEscape(file_descriptor_serialized_));
+  if (file_->dependency_count() != 0) {
+    printer_->Print(",\ndependencies=[");
+    for (int i = 0; i < file_->dependency_count(); ++i) {
+      string module_alias = ModuleAlias(file_->dependency(i)->name());
+      printer_->Print("$module_alias$.DESCRIPTOR,", "module_alias",
+                      module_alias);
+    }
+    printer_->Print("]");
+  }
 
   // TODO(falk): Also print options and fix the message_type, enum_type,
   //             service and extension later in the generation.
 
   printer_->Outdent();
   printer_->Print(")\n");
+  printer_->Print("_sym_db.RegisterFileDescriptor($name$)\n", "name",
+                  kDescriptorKey);
   printer_->Print("\n");
 }
 
 // Prints descriptors and module-level constants for all top-level
 // enums defined in |file|.
 void Generator::PrintTopLevelEnums() const {
   vector<pair<string, int> > top_level_enum_values;
   for (int i = 0; i < file_->enum_type_count(); ++i) {
     const EnumDescriptor& enum_descriptor = *file_->enum_type(i);
     PrintEnum(enum_descriptor);
     printer_->Print("$name$ = "
                     "enum_type_wrapper.EnumTypeWrapper($descriptor_name$)",
                     "name", enum_descriptor.name(),
                     "descriptor_name",
                     ModuleLevelDescriptorName(enum_descriptor));
     printer_->Print("\n");
 
     for (int j = 0; j < enum_descriptor.value_count(); ++j) {
       const EnumValueDescriptor& value_descriptor = *enum_descriptor.value(j);
       top_level_enum_values.push_back(
-          make_pair(value_descriptor.name(), value_descriptor.number()));
+          std::make_pair(value_descriptor.name(), value_descriptor.number()));
     }
   }
 
   for (int i = 0; i < top_level_enum_values.size(); ++i) {
     printer_->Print("$name$ = $value$\n",
                     "name", top_level_enum_values[i].first,
                     "value", SimpleItoa(top_level_enum_values[i].second));
   }
   printer_->Print("\n");
 }
 
 // Prints all enums contained in all message types in |file|.
 void Generator::PrintAllNestedEnumsInFile() const {
   for (int i = 0; i < file_->message_type_count(); ++i) {
     PrintNestedEnums(*file_->message_type(i));
   }
 }
 
 // Prints a Python statement assigning the appropriate module-level
 // enum name to a Python EnumDescriptor object equivalent to
 // enum_descriptor.
 void Generator::PrintEnum(const EnumDescriptor& enum_descriptor) const {
   map<string, string> m;
-  m["descriptor_name"] = ModuleLevelDescriptorName(enum_descriptor);
+  string module_level_descriptor_name =
+      ModuleLevelDescriptorName(enum_descriptor);
+  m["descriptor_name"] = module_level_descriptor_name;
   m["name"] = enum_descriptor.name();
   m["full_name"] = enum_descriptor.full_name();
   m["file"] = kDescriptorKey;
   const char enum_descriptor_template[] =
       "$descriptor_name$ = _descriptor.EnumDescriptor(\n"
       "  name='$name$',\n"
       "  full_name='$full_name$',\n"
       "  filename=None,\n"
       "  file=$file$,\n"
       "  values=[\n";
   string options_string;
   enum_descriptor.options().SerializeToString(&options_string);
   printer_->Print(m, enum_descriptor_template);
   printer_->Indent();
   printer_->Indent();
   for (int i = 0; i < enum_descriptor.value_count(); ++i) {
     PrintEnumValueDescriptor(*enum_descriptor.value(i));
     printer_->Print(",\n");
   }
   printer_->Outdent();
   printer_->Print("],\n");
   printer_->Print("containing_type=None,\n");
   printer_->Print("options=$options_value$,\n",
                   "options_value",
                   OptionsValue("EnumOptions", options_string));
   EnumDescriptorProto edp;
   PrintSerializedPbInterval(enum_descriptor, edp);
   printer_->Outdent();
   printer_->Print(")\n");
+  printer_->Print("_sym_db.RegisterEnumDescriptor($name$)\n", "name",
+                  module_level_descriptor_name);
   printer_->Print("\n");
 }
 
 // Recursively prints enums in nested types within descriptor, then
 // prints enums contained at the top level in descriptor.
 void Generator::PrintNestedEnums(const Descriptor& descriptor) const {
   for (int i = 0; i < descriptor.nested_type_count(); ++i) {
     PrintNestedEnums(*descriptor.nested_type(i));
   }
 
@@ skipping 88 matching lines @@
         "output_type=$output_type$,\n"
         "options=$options_value$,\n");
     printer_->Outdent();
     printer_->Print("),\n");
   }
 
   printer_->Outdent();
   printer_->Print("])\n\n");
 }
 
+
+void Generator::PrintDescriptorKeyAndModuleName(
+    const ServiceDescriptor& descriptor) const {
+  printer_->Print(
+      "$descriptor_key$ = $descriptor_name$,\n",
+      "descriptor_key", kDescriptorKey,
+      "descriptor_name", ModuleLevelServiceDescriptorName(descriptor));
+  printer_->Print(
+      "__module__ = '$module_name$'\n",
+      "module_name", ModuleName(file_->name()));
+}
+
 void Generator::PrintServiceClass(const ServiceDescriptor& descriptor) const {
   // Print the service.
-  printer_->Print("class $class_name$(_service.Service):\n",
+  printer_->Print("$class_name$ = service_reflection.GeneratedServiceType("
+                  "'$class_name$', (_service.Service,), dict(\n",
                   "class_name", descriptor.name());
   printer_->Indent();
-  printer_->Print(
-      "__metaclass__ = service_reflection.GeneratedServiceType\n"
-      "$descriptor_key$ = $descriptor_name$\n",
-      "descriptor_key", kDescriptorKey,
-      "descriptor_name", ModuleLevelServiceDescriptorName(descriptor));
+  Generator::PrintDescriptorKeyAndModuleName(descriptor);
+  printer_->Print("))\n\n");
   printer_->Outdent();
 }
 
 void Generator::PrintServiceStub(const ServiceDescriptor& descriptor) const {
   // Print the service stub.
-  printer_->Print("class $class_name$_Stub($class_name$):\n",
+  printer_->Print("$class_name$_Stub = "
+                  "service_reflection.GeneratedServiceStubType("
+                  "'$class_name$_Stub', ($class_name$,), dict(\n",
                   "class_name", descriptor.name());
   printer_->Indent();
-  printer_->Print(
-      "__metaclass__ = service_reflection.GeneratedServiceStubType\n"
-      "$descriptor_key$ = $descriptor_name$\n",
-      "descriptor_key", kDescriptorKey,
-      "descriptor_name", ModuleLevelServiceDescriptorName(descriptor));
+  Generator::PrintDescriptorKeyAndModuleName(descriptor);
+  printer_->Print("))\n\n");
   printer_->Outdent();
 }
 
 // Prints statement assigning ModuleLevelDescriptorName(message_descriptor)
 // to a Python Descriptor object for message_descriptor.
 //
 // Mutually recursive with PrintNestedDescriptors().
 void Generator::PrintDescriptor(const Descriptor& message_descriptor) const {
   PrintNestedDescriptors(message_descriptor);
 
@@ skipping 33 matching lines @@
         *message_descriptor.enum_type(i));
     printer_->Print(descriptor_name.c_str());
     printer_->Print(",\n");
   }
   printer_->Outdent();
   printer_->Print("],\n");
   string options_string;
   message_descriptor.options().SerializeToString(&options_string);
   printer_->Print(
       "options=$options_value$,\n"
-      "is_extendable=$extendable$",
+      "is_extendable=$extendable$,\n"
+      "syntax='$syntax$'",
       "options_value", OptionsValue("MessageOptions", options_string),
       "extendable", message_descriptor.extension_range_count() > 0 ?
-                      "True" : "False");
+                      "True" : "False",
+      "syntax", StringifySyntax(message_descriptor.file()->syntax()));
   printer_->Print(",\n");
 
   // Extension ranges
   printer_->Print("extension_ranges=[");
   for (int i = 0; i < message_descriptor.extension_range_count(); ++i) {
     const Descriptor::ExtensionRange* range =
         message_descriptor.extension_range(i);
     printer_->Print("($start$, $end$), ",
                     "start", SimpleItoa(range->start),
                     "end", SimpleItoa(range->end));
   }
   printer_->Print("],\n");
-
+  printer_->Print("oneofs=[\n");
+  printer_->Indent();
+  for (int i = 0; i < message_descriptor.oneof_decl_count(); ++i) {
+    const OneofDescriptor* desc = message_descriptor.oneof_decl(i);
+    map<string, string> m;
+    m["name"] = desc->name();
+    m["full_name"] = desc->full_name();
+    m["index"] = SimpleItoa(desc->index());
+    printer_->Print(
+        m,
+        "_descriptor.OneofDescriptor(\n"
+        "  name='$name$', full_name='$full_name$',\n"
+        "  index=$index$, containing_type=None, fields=[]),\n");
+  }
+  printer_->Outdent();
+  printer_->Print("],\n");
   // Serialization of proto
   DescriptorProto edp;
   PrintSerializedPbInterval(message_descriptor, edp);
 
   printer_->Outdent();
   printer_->Print(")\n");
 }
 
 // Prints Python Descriptor objects for all nested types contained in
 // message_descriptor.
 //
 // Mutually recursive with PrintDescriptor().
 void Generator::PrintNestedDescriptors(
     const Descriptor& containing_descriptor) const {
   for (int i = 0; i < containing_descriptor.nested_type_count(); ++i) {
     PrintDescriptor(*containing_descriptor.nested_type(i));
   }
 }
 
 // Prints all messages in |file|.
 void Generator::PrintMessages() const {
   for (int i = 0; i < file_->message_type_count(); ++i) {
-    PrintMessage(*file_->message_type(i));
+    vector<string> to_register;
+    PrintMessage(*file_->message_type(i), "", &to_register);
+    for (int j = 0; j < to_register.size(); ++j) {
+      printer_->Print("_sym_db.RegisterMessage($name$)\n", "name",
+                      to_register[j]);
+    }
     printer_->Print("\n");
   }
 }
 
 // Prints a Python class for the given message descriptor.  We defer to the
 // metaclass to do almost all of the work of actually creating a useful class.
 // The purpose of this function and its many helper functions above is merely
 // to output a Python version of the descriptors, which the metaclass in
 // reflection.py will use to construct the meat of the class itself.
 //
 // Mutually recursive with PrintNestedMessages().
-void Generator::PrintMessage(
-    const Descriptor& message_descriptor) const {
-  printer_->Print("class $name$(_message.Message):\n", "name",
-                  message_descriptor.name());
+// Collect nested message names to_register for the symbol_database.
+void Generator::PrintMessage(const Descriptor& message_descriptor,
+                             const string& prefix,
+                             vector<string>* to_register) const {
+  string qualified_name(prefix + message_descriptor.name());
+  to_register->push_back(qualified_name);
+  printer_->Print(
+      "$name$ = _reflection.GeneratedProtocolMessageType('$name$', "
+      "(_message.Message,), dict(\n",
+      "name", message_descriptor.name());
   printer_->Indent();
-  printer_->Print("__metaclass__ = _reflection.GeneratedProtocolMessageType\n");
-  PrintNestedMessages(message_descriptor);
+
+  PrintNestedMessages(message_descriptor, qualified_name + ".", to_register);
   map<string, string> m;
   m["descriptor_key"] = kDescriptorKey;
   m["descriptor_name"] = ModuleLevelDescriptorName(message_descriptor);
-  printer_->Print(m, "$descriptor_key$ = $descriptor_name$\n");
-
-  printer_->Print(
-    "\n"
-    "# @@protoc_insertion_point(class_scope:$full_name$)\n",
-    "full_name", message_descriptor.full_name());
-
+  printer_->Print(m, "$descriptor_key$ = $descriptor_name$,\n");
+  printer_->Print("__module__ = '$module_name$'\n",
+                  "module_name", ModuleName(file_->name()));
+  printer_->Print("# @@protoc_insertion_point(class_scope:$full_name$)\n",
+                  "full_name", message_descriptor.full_name());
+  printer_->Print("))\n");
   printer_->Outdent();
 }
 
 // Prints all nested messages within |containing_descriptor|.
 // Mutually recursive with PrintMessage().
-void Generator::PrintNestedMessages(
-    const Descriptor& containing_descriptor) const {
+void Generator::PrintNestedMessages(const Descriptor& containing_descriptor,
+                                    const string& prefix,
+                                    vector<string>* to_register) const {
   for (int i = 0; i < containing_descriptor.nested_type_count(); ++i) {
     printer_->Print("\n");
-    PrintMessage(*containing_descriptor.nested_type(i));
+    PrintMessage(*containing_descriptor.nested_type(i), prefix, to_register);
+    printer_->Print(",\n");
   }
 }
 
 // Recursively fixes foreign fields in all nested types in |descriptor|, then
 // sets the message_type and enum_type of all message and enum fields to point
 // to their respective descriptors.
 // Args:
 //   descriptor: descriptor to print fields for.
 //   containing_descriptor: if descriptor is a nested type, this is its
 //       containing type, or NULL if this is a root/top-level type.
 void Generator::FixForeignFieldsInDescriptor(
     const Descriptor& descriptor,
     const Descriptor* containing_descriptor) const {
   for (int i = 0; i < descriptor.nested_type_count(); ++i) {
     FixForeignFieldsInDescriptor(*descriptor.nested_type(i), &descriptor);
   }
 
   for (int i = 0; i < descriptor.field_count(); ++i) {
     const FieldDescriptor& field_descriptor = *descriptor.field(i);
     FixForeignFieldsInField(&descriptor, field_descriptor, "fields_by_name");
   }
 
   FixContainingTypeInDescriptor(descriptor, containing_descriptor);
   for (int i = 0; i < descriptor.enum_type_count(); ++i) {
     const EnumDescriptor& enum_descriptor = *descriptor.enum_type(i);
     FixContainingTypeInDescriptor(enum_descriptor, &descriptor);
   }
+  for (int i = 0; i < descriptor.oneof_decl_count(); ++i) {
+    map<string, string> m;
+    const OneofDescriptor* oneof = descriptor.oneof_decl(i);
+    m["descriptor_name"] = ModuleLevelDescriptorName(descriptor);
+    m["oneof_name"] = oneof->name();
+    for (int j = 0; j < oneof->field_count(); ++j) {
+      m["field_name"] = oneof->field(j)->name();
+      printer_->Print(
+          m,
+          "$descriptor_name$.oneofs_by_name['$oneof_name$'].fields.append(\n"
+          "  $descriptor_name$.fields_by_name['$field_name$'])\n");
+      printer_->Print(
+          m,
+          "$descriptor_name$.fields_by_name['$field_name$'].containing_oneof = "
+          "$descriptor_name$.oneofs_by_name['$oneof_name$']\n");
+    }
+  }
 }
 
 void Generator::AddMessageToFileDescriptor(const Descriptor& descriptor) const {
   map<string, string> m;
   m["descriptor_name"] = kDescriptorKey;
   m["message_name"] = descriptor.name();
   m["message_descriptor_name"] = ModuleLevelDescriptorName(descriptor);
   const char file_descriptor_template[] =
       "$descriptor_name$.message_types_by_name['$message_name$'] = "
       "$message_descriptor_name$\n";
   printer_->Print(m, file_descriptor_template);
 }
 
+void Generator::AddEnumToFileDescriptor(
+    const EnumDescriptor& descriptor) const {
+  map<string, string> m;
+  m["descriptor_name"] = kDescriptorKey;
+  m["enum_name"] = descriptor.name();
+  m["enum_descriptor_name"] = ModuleLevelDescriptorName(descriptor);
+  const char file_descriptor_template[] =
+      "$descriptor_name$.enum_types_by_name['$enum_name$'] = "
+      "$enum_descriptor_name$\n";
+  printer_->Print(m, file_descriptor_template);
+}
+
+void Generator::AddExtensionToFileDescriptor(
+    const FieldDescriptor& descriptor) const {
+  map<string, string> m;
+  m["descriptor_name"] = kDescriptorKey;
+  m["field_name"] = descriptor.name();
+  const char file_descriptor_template[] =
+      "$descriptor_name$.extensions_by_name['$field_name$'] = "
+      "$field_name$\n";
+  printer_->Print(m, file_descriptor_template);
+}
+
 // Sets any necessary message_type and enum_type attributes
 // for the Python version of |field|.
 //
 // containing_type may be NULL, in which case this is a module-level field.
 //
 // python_dict_name is the name of the Python dict where we should
 // look the field up in the containing type.  (e.g., fields_by_name
 // or extensions_by_name).  We ignore python_dict_name if containing_type
 // is NULL.
 void Generator::FixForeignFieldsInField(const Descriptor* containing_type,
@@ skipping 44 matching lines @@
 // Prints containing_type for nested descriptors or enum descriptors.
 template <typename DescriptorT>
 void Generator::FixContainingTypeInDescriptor(
     const DescriptorT& descriptor,
     const Descriptor* containing_descriptor) const {
   if (containing_descriptor != NULL) {
     const string nested_name = ModuleLevelDescriptorName(descriptor);
     const string parent_name = ModuleLevelDescriptorName(
         *containing_descriptor);
     printer_->Print(
-        "$nested_name$.containing_type = $parent_name$;\n",
+        "$nested_name$.containing_type = $parent_name$\n",
         "nested_name", nested_name,
         "parent_name", parent_name);
   }
 }
 
 // Prints statements setting the message_type and enum_type fields in the
 // Python descriptor objects we've already output in ths file.  We must
 // do this in a separate step due to circular references (otherwise, we'd
 // just set everything in the initial assignment statements).
 void Generator::FixForeignFieldsInDescriptors() const {
   for (int i = 0; i < file_->message_type_count(); ++i) {
     FixForeignFieldsInDescriptor(*file_->message_type(i), NULL);
   }
   for (int i = 0; i < file_->message_type_count(); ++i) {
     AddMessageToFileDescriptor(*file_->message_type(i));
   }
+  for (int i = 0; i < file_->enum_type_count(); ++i) {
+    AddEnumToFileDescriptor(*file_->enum_type(i));
+  }
+  for (int i = 0; i < file_->extension_count(); ++i) {
+    AddExtensionToFileDescriptor(*file_->extension(i));
+  }
   printer_->Print("\n");
 }
 
 // We need to not only set any necessary message_type fields, but
 // also need to call RegisterExtension() on each message we're
 // extending.
 void Generator::FixForeignFieldsInExtensions() const {
   // Top-level extensions.
   for (int i = 0; i < file_->extension_count(); ++i) {
     FixForeignFieldsInExtension(*file_->extension(i));
@@ skipping 60 matching lines @@
 }
 
 // Returns a Python expression that calls descriptor._ParseOptions using
 // the given descriptor class name and serialized options protobuf string.
 string Generator::OptionsValue(
     const string& class_name, const string& serialized_options) const {
   if (serialized_options.length() == 0 || GeneratingDescriptorProto()) {
     return "None";
   } else {
     string full_class_name = "descriptor_pb2." + class_name;
-    return "_descriptor._ParseOptions(" + full_class_name + "(), '"
-        + CEscape(serialized_options)+ "')";
+//##!PY25    return "_descriptor._ParseOptions(" + full_class_name + "(), b'"
+//##!PY25        + CEscape(serialized_options)+ "')";
+    return "_descriptor._ParseOptions(" + full_class_name + "(), _b('"  //##PY25
+        + CEscape(serialized_options)+ "'))";  //##PY25
   }
 }
 
 // Prints an expression for a Python FieldDescriptor for |field|.
 void Generator::PrintFieldDescriptor(
     const FieldDescriptor& field, bool is_extension) const {
   string options_string;
   field.options().SerializeToString(&options_string);
   map<string, string> m;
   m["name"] = field.name();
@@ skipping 82 matching lines @@
   // The C++ implementation doesn't guard against this either.  Leaving
   // it for now...
   string name = NamePrefixedWithNestedTypes(descriptor, "_");
   UpperString(&name);
   // Module-private for now.  Easy to make public later; almost impossible
   // to make private later.
   name = "_" + name;
   // We now have the name relative to its own module.  Also qualify with
   // the module name iff this descriptor is from a different .proto file.
   if (descriptor.file() != file_) {
-    name = ModuleName(descriptor.file()->name()) + "." + name;
+    name = ModuleAlias(descriptor.file()->name()) + "." + name;
   }
   return name;
 }
 
 // Returns the name of the message class itself, not the descriptor.
 // Like ModuleLevelDescriptorName(), module-qualifies the name iff
 // the given descriptor describes an entity that doesn't come from
 // the current file.
 string Generator::ModuleLevelMessageName(const Descriptor& descriptor) const {
   string name = NamePrefixedWithNestedTypes(descriptor, ".");
   if (descriptor.file() != file_) {
-    name = ModuleName(descriptor.file()->name()) + "." + name;
+    name = ModuleAlias(descriptor.file()->name()) + "." + name;
   }
   return name;
 }
 
 // Returns the unique Python module-level identifier given to a service
 // descriptor.
 string Generator::ModuleLevelServiceDescriptorName(
     const ServiceDescriptor& descriptor) const {
   string name = descriptor.name();
   UpperString(&name);
   name = "_" + name;
   if (descriptor.file() != file_) {
-    name = ModuleName(descriptor.file()->name()) + "." + name;
+    name = ModuleAlias(descriptor.file()->name()) + "." + name;
   }
   return name;
 }
 
 // Prints standard constructor arguments serialized_start and serialized_end.
 // Args:
 //   descriptor: The cpp descriptor to have a serialized reference.
 //   proto: A proto
 // Example printer output:
 // serialized_start=41,
@@ skipping 126 matching lines @@
   string message_options = OptionsValue(
       "MessageOptions", descriptor.options().SerializeAsString());
   if (message_options != "None") {
     string descriptor_name = ModuleLevelDescriptorName(descriptor);
     PrintDescriptorOptionsFixingCode(descriptor_name,
                                      message_options,
                                      printer_);
   }
 }
 
+// If a dependency forwards other files through public dependencies, let's
+// copy over the corresponding module aliases.
+void Generator::CopyPublicDependenciesAliases(
+    const string& copy_from, const FileDescriptor* file) const {
+  for (int i = 0; i < file->public_dependency_count(); ++i) {
+    string module_alias = ModuleAlias(file->public_dependency(i)->name());
+    printer_->Print("$alias$ = $copy_from$.$alias$\n", "alias", module_alias,
+                    "copy_from", copy_from);
+    CopyPublicDependenciesAliases(copy_from, file->public_dependency(i));
+  }
+}
+
 }  // namespace python
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google