third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/compiler/command_line_interface.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 32 matching lines @@
 #include <io.h>
 #include <direct.h>
 #else
 #include <unistd.h>
 #endif
 #include <errno.h>
 #include <fstream>
 #include <iostream>
 #include <ctype.h>
 
-#ifdef GOOGLE_PROTOBUF_ARCH_SPARC
 #include <limits.h> //For PATH_MAX
-#endif
 
 #include <memory>
 #ifndef _SHARED_PTR_H
 #include <google/protobuf/stubs/shared_ptr.h>
 #endif
 
 #ifdef __APPLE__
 #include <mach-o/dyld.h>
 #endif
 
@@ skipping 102 matching lines @@
     return true;
   }
 }
 
 // Try to create the parent directory of the given file, creating the parent's
 // parent if necessary, and so on.  The full file name is actually
 // (prefix + filename), but we assume |prefix| already exists and only create
 // directories listed in |filename|.
 bool TryCreateParentDirectory(const string& prefix, const string& filename) {
   // Recursively create parent directories to the output file.
-  vector<string> parts = Split(filename, "/", true);
+  std::vector<string> parts =
+      Split(filename, "/", true);
   string path_so_far = prefix;
   for (int i = 0; i < parts.size() - 1; i++) {
     path_so_far += parts[i];
     if (mkdir(path_so_far.c_str(), 0777) != 0) {
       if (errno != EEXIST) {
         std::cerr << filename << ": while trying to create directory "
                   << path_so_far << ": " << strerror(errno) << std::endl;
         return false;
       }
     }
@@ skipping 68 matching lines @@
   pos = path.find_last_of("/\\");
   if (pos == string::npos || pos == 0) {
     return;
   }
   path = path.substr(0, pos);
   if (IsInstalledProtoPath(path + "/include")) {
     paths->push_back(pair<string, string>("", path + "/include"));
     return;
   }
 }
+
+string PluginName(const string& plugin_prefix, const string& directive) {
+  // Assuming the directive starts with "--" and ends with "_out" or "_opt",
+  // strip the "--" and "_out/_opt" and add the plugin prefix.
+  return plugin_prefix + "gen-" + directive.substr(2, directive.size() - 6);
+}
 }  // namespace
 
 // A MultiFileErrorCollector that prints errors to stderr.
 class CommandLineInterface::ErrorPrinter : public MultiFileErrorCollector,
                                            public io::ErrorCollector {
  public:
   ErrorPrinter(ErrorFormat format, DiskSourceTree *tree = NULL)
     : format_(format), tree_(tree) {}
   ~ErrorPrinter() {}
 
@@ skipping 56 matching lines @@
   const ErrorFormat format_;
   DiskSourceTree *tree_;
 };
 
 // -------------------------------------------------------------------
 
 // A GeneratorContext implementation that buffers files in memory, then dumps
 // them all to disk on demand.
 class CommandLineInterface::GeneratorContextImpl : public GeneratorContext {
  public:
-  GeneratorContextImpl(const vector<const FileDescriptor*>& parsed_files);
+  GeneratorContextImpl(const std::vector<const FileDescriptor*>& parsed_files);
   ~GeneratorContextImpl();
 
   // Write all files in the directory to disk at the given output location,
   // which must end in a '/'.
   bool WriteAllToDisk(const string& prefix);
 
   // Write the contents of this directory to a ZIP-format archive with the
   // given name.
   bool WriteAllToZip(const string& filename);
 
   // Add a boilerplate META-INF/MANIFEST.MF file as required by the Java JAR
   // format, unless one has already been written.
   void AddJarManifest();
 
   // Get name of all output files.
-  void GetOutputFilenames(vector<string>* output_filenames);
+  void GetOutputFilenames(std::vector<string>* output_filenames);
 
   // implements GeneratorContext --------------------------------------
   io::ZeroCopyOutputStream* Open(const string& filename);
   io::ZeroCopyOutputStream* OpenForAppend(const string& filename);
   io::ZeroCopyOutputStream* OpenForInsert(
       const string& filename, const string& insertion_point);
-  void ListParsedFiles(vector<const FileDescriptor*>* output) {
+  void ListParsedFiles(std::vector<const FileDescriptor*>* output) {
     *output = parsed_files_;
   }
 
  private:
   friend class MemoryOutputStream;
 
   // map instead of hash_map so that files are written in order (good when
   // writing zips).
-  map<string, string*> files_;
-  const vector<const FileDescriptor*>& parsed_files_;
+  std::map<string, string*> files_;
+  const std::vector<const FileDescriptor*>& parsed_files_;
   bool had_error_;
 };
 
 class CommandLineInterface::MemoryOutputStream
     : public io::ZeroCopyOutputStream {
  public:
   MemoryOutputStream(GeneratorContextImpl* directory, const string& filename,
                      bool append_mode);
   MemoryOutputStream(GeneratorContextImpl* directory, const string& filename,
                      const string& insertion_point);
@@ skipping 16 matching lines @@
   // Whether we should append the output stream to the existing file.
   bool append_mode_;
 
   // StringOutputStream writing to data_.
   google::protobuf::scoped_ptr<io::StringOutputStream> inner_;
 };
 
 // -------------------------------------------------------------------
 
 CommandLineInterface::GeneratorContextImpl::GeneratorContextImpl(
-    const vector<const FileDescriptor*>& parsed_files)
+    const std::vector<const FileDescriptor*>& parsed_files)
     : parsed_files_(parsed_files),
       had_error_(false) {
 }
 
 CommandLineInterface::GeneratorContextImpl::~GeneratorContextImpl() {
   STLDeleteValues(&files_);
 }
 
 bool CommandLineInterface::GeneratorContextImpl::WriteAllToDisk(
     const string& prefix) {
   if (had_error_) {
     return false;
   }
 
   if (!VerifyDirectoryExists(prefix)) {
     return false;
   }
 
-  for (map<string, string*>::const_iterator iter = files_.begin();
+  for (std::map<string, string*>::const_iterator iter = files_.begin();
        iter != files_.end(); ++iter) {
     const string& relative_filename = iter->first;
     const char* data = iter->second->data();
     int size = iter->second->size();
 
     if (!TryCreateParentDirectory(prefix, relative_filename)) {
       return false;
     }
     string filename = prefix + relative_filename;
 
@@ skipping 67 matching lines @@
   if (file_descriptor < 0) {
     int error = errno;
     std::cerr << filename << ": " << strerror(error);
     return false;
   }
 
   // Create the ZipWriter
   io::FileOutputStream stream(file_descriptor);
   ZipWriter zip_writer(&stream);
 
-  for (map<string, string*>::const_iterator iter = files_.begin();
+  for (std::map<string, string*>::const_iterator iter = files_.begin();
        iter != files_.end(); ++iter) {
     zip_writer.Write(iter->first, *iter->second);
   }
 
   zip_writer.WriteDirectory();
 
   if (stream.GetErrno() != 0) {
     std::cerr << filename << ": " << strerror(stream.GetErrno()) << std::endl;
   }
 
   if (!stream.Close()) {
     std::cerr << filename << ": " << strerror(stream.GetErrno()) << std::endl;
   }
 
   return true;
 }
 
 void CommandLineInterface::GeneratorContextImpl::AddJarManifest() {
   string** map_slot = &files_["META-INF/MANIFEST.MF"];
   if (*map_slot == NULL) {
     *map_slot = new string(
         "Manifest-Version: 1.0\n"
         "Created-By: 1.6.0 (protoc)\n"
         "\n");
   }
 }
 
 void CommandLineInterface::GeneratorContextImpl::GetOutputFilenames(
-    vector<string>* output_filenames) {
-  for (map<string, string*>::iterator iter = files_.begin();
+    std::vector<string>* output_filenames) {
+  for (std::map<string, string*>::iterator iter = files_.begin();
        iter != files_.end(); ++iter) {
     output_filenames->push_back(iter->first);
   }
 }
 
 io::ZeroCopyOutputStream* CommandLineInterface::GeneratorContextImpl::Open(
     const string& filename) {
   return new MemoryOutputStream(this, filename, false);
 }
 
@@ skipping 46 matching lines @@
         directory_->had_error_ = true;
       }
       return;
     }
 
     *map_slot = new string;
     (*map_slot)->swap(data_);
   } else {
     // This was an OpenForInsert().
 
-    // If the data doens't end with a clean line break, add one.
+    // If the data doesn't end with a clean line break, add one.
     if (!data_.empty() && data_[data_.size() - 1] != '\n') {
       data_.push_back('\n');
     }
 
     // Find the file we are going to insert into.
     if (*map_slot == NULL) {
       std::cerr << filename_
                 << ": Tried to insert into file that doesn't exist."
                 << std::endl;
       directory_->had_error_ = true;
       return;
     }
     string* target = *map_slot;
 
     // Find the insertion point.
     string magic_string = strings::Substitute(
         "@@protoc_insertion_point($0)", insertion_point_);
     string::size_type pos = target->find(magic_string);
 
     if (pos == string::npos) {
       std::cerr << filename_ << ": insertion point \"" << insertion_point_
                 << "\" not found." << std::endl;
       directory_->had_error_ = true;
       return;
     }
 
-    // Seek backwards to the beginning of the line, which is where we will
-    // insert the data.  Note that this has the effect of pushing the insertion
-    // point down, so the data is inserted before it.  This is intentional
-    // because it means that multiple insertions at the same point will end
-    // up in the expected order in the final output.
-    pos = target->find_last_of('\n', pos);
-    if (pos == string::npos) {
-      // Insertion point is on the first line.
-      pos = 0;
+    if ((pos > 3) && (target->substr(pos - 3, 2) == "/*")) {
+      // Support for inline "/* @@protoc_insertion_point() */"
+      pos = pos - 3;
     } else {
-      // Advance to character after '\n'.
-      ++pos;
+      // Seek backwards to the beginning of the line, which is where we will
+      // insert the data.  Note that this has the effect of pushing the
+      // insertion point down, so the data is inserted before it.  This is
+      // intentional because it means that multiple insertions at the same point
+      // will end up in the expected order in the final output.
+      pos = target->find_last_of('\n', pos);
+      if (pos == string::npos) {
+        // Insertion point is on the first line.
+        pos = 0;
+      } else {
+        // Advance to character after '\n'.
+        ++pos;
+      }
     }
 
     // Extract indent.
     string indent_(*target, pos, target->find_first_not_of(" \t", pos) - pos);
 
     if (indent_.empty()) {
       // No indent.  This makes things easier.
       target->insert(pos, data_);
     } else {
       // Calculate how much space we need.
@@ skipping 28 matching lines @@
     }
   }
 }
 
 // ===================================================================
 
 CommandLineInterface::CommandLineInterface()
   : mode_(MODE_COMPILE),
     print_mode_(PRINT_NONE),
     error_format_(ERROR_FORMAT_GCC),
+    direct_dependencies_explicitly_set_(false),
     imports_in_descriptor_set_(false),
     source_info_in_descriptor_set_(false),
     disallow_services_(false),
     inputs_are_proto_path_relative_(false) {}
 CommandLineInterface::~CommandLineInterface() {}
 
 void CommandLineInterface::RegisterGenerator(const string& flag_name,
                                              CodeGenerator* generator,
                                              const string& help_text) {
   GeneratorInfo info;
@@ skipping 43 matching lines @@
   if (!inputs_are_proto_path_relative_) {
     if (!MakeInputsBeProtoPathRelative(&source_tree)) {
       return 1;
     }
   }
 
   // Allocate the Importer.
   ErrorPrinter error_collector(error_format_, &source_tree);
   Importer importer(&source_tree, &error_collector);
 
-  vector<const FileDescriptor*> parsed_files;
+  std::vector<const FileDescriptor*> parsed_files;
 
   // Parse each file.
   for (int i = 0; i < input_files_.size(); i++) {
     // Import the file.
     importer.AddUnusedImportTrackFile(input_files_[i]);
     const FileDescriptor* parsed_file = importer.Import(input_files_[i]);
     importer.ClearUnusedImportTrackFiles();
     if (parsed_file == NULL) return 1;
     parsed_files.push_back(parsed_file);
 
     // Enforce --disallow_services.
     if (disallow_services_ && parsed_file->service_count() > 0) {
       cerr << parsed_file->name() << ": This file contains services, but "
               "--disallow_services was used." << endl;
       return 1;
     }
+
+    // Enforce --direct_dependencies
+    if (direct_dependencies_explicitly_set_) {
+      bool indirect_imports = false;
+      for (int i = 0; i < parsed_file->dependency_count(); i++) {
+        if (direct_dependencies_.find(parsed_file->dependency(i)->name()) ==
+            direct_dependencies_.end()) {
+          indirect_imports = true;
+          cerr << parsed_file->name()
+               << ": File is imported but not declared in "
+               << "--direct_dependencies: "
+               << parsed_file->dependency(i)->name() << std::endl;
+        }
+      }
+      if (indirect_imports) {
+        return 1;
+      }
+    }
   }
 
   // We construct a separate GeneratorContext for each output location.  Note
   // that two code generators may output to the same location, in which case
   // they should share a single GeneratorContext so that OpenForInsert() works.
   GeneratorContextMap output_directories;
 
   // Generate output.
   if (mode_ == MODE_COMPILE) {
     for (int i = 0; i < output_directives_.size(); i++) {
@@ skipping 93 matching lines @@
 
   return 0;
 }
 
 void CommandLineInterface::Clear() {
   // Clear all members that are set by Run().  Note that we must not clear
   // members which are set by other methods before Run() is called.
   executable_name_.clear();
   proto_path_.clear();
   input_files_.clear();
+  direct_dependencies_.clear();
   output_directives_.clear();
   codec_type_.clear();
   descriptor_set_name_.clear();
   dependency_out_name_.clear();
 
   mode_ = MODE_COMPILE;
   print_mode_ = PRINT_NONE;
   imports_in_descriptor_set_ = false;
   source_info_in_descriptor_set_ = false;
   disallow_services_ = false;
+  direct_dependencies_explicitly_set_ = false;
 }
 
 bool CommandLineInterface::MakeInputsBeProtoPathRelative(
     DiskSourceTree* source_tree) {
   for (int i = 0; i < input_files_.size(); i++) {
     string virtual_file, shadowing_disk_file;
     switch (source_tree->DiskFileToVirtualFile(
         input_files_[i], &virtual_file, &shadowing_disk_file)) {
       case DiskSourceTree::SUCCESS:
         input_files_[i] = virtual_file;
@@ skipping 30 matching lines @@
   }
 
   return true;
 }
 
 
 CommandLineInterface::ParseArgumentStatus
 CommandLineInterface::ParseArguments(int argc, const char* const argv[]) {
   executable_name_ = argv[0];
 
-  vector<string> arguments;
+  std::vector<string> arguments;
   for (int i = 1; i < argc; ++i) {
     arguments.push_back(argv[i]);
   }
 
   // Iterate through all arguments and parse them.
   for (int i = 0; i < arguments.size(); ++i) {
     string name, value;
 
     if (ParseArgument(arguments[i].c_str(), &name, &value)) {
       // Returned true => Use the next argument as the flag value.
       if (i + 1 == arguments.size() || arguments[i + 1][0] == '-') {
         std::cerr << "Missing value for flag: " << name << std::endl;
         if (name == "--decode") {
           std::cerr << "To decode an unknown message, use --decode_raw."
                     << std::endl;
         }
         return PARSE_ARGUMENT_FAIL;
       } else {
         ++i;
         value = arguments[i];
       }
     }
 
     ParseArgumentStatus status = InterpretArgument(name, value);
     if (status != PARSE_ARGUMENT_DONE_AND_CONTINUE)
       return status;
   }
 
+  // Make sure each plugin option has a matching plugin output.
+  for (map<string, string>::const_iterator i = plugin_parameters_.begin();
+       i != plugin_parameters_.end(); ++i) {
+    if (plugins_.find(i->first) == plugins_.end()) {
+      std::cerr << "Unknown flag: "
+                // strip prefix + "gen-" and add back "_opt"
+                << "--" + i->first.substr(plugin_prefix_.size() + 4) + "_opt"
+                << std::endl;
+      return PARSE_ARGUMENT_FAIL;
+    }
+  }
+
   // If no --proto_path was given, use the current working directory.
   if (proto_path_.empty()) {
     // Don't use make_pair as the old/default standard library on Solaris
     // doesn't support it without explicit template parameters, which are
     // incompatible with C++0x's make_pair.
-    proto_path_.push_back(pair<string, string>("", "."));
+    proto_path_.push_back(std::pair<string, string>("", "."));
   }
 
   // Check some errror cases.
   bool decoding_raw = (mode_ == MODE_DECODE) && codec_type_.empty();
   if (decoding_raw && !input_files_.empty()) {
     std::cerr << "When using --decode_raw, no input files should be given."
               << std::endl;
     return PARSE_ARGUMENT_FAIL;
   } else if (!decoding_raw && input_files_.empty()) {
     std::cerr << "Missing input file." << std::endl;
@@ skipping 102 matching lines @@
              "input so the program is going to die now." << std::endl;
       return PARSE_ARGUMENT_FAIL;
     }
 
     input_files_.push_back(value);
 
   } else if (name == "-I" || name == "--proto_path") {
     // Java's -classpath (and some other languages) delimits path components
     // with colons.  Let's accept that syntax too just to make things more
     // intuitive.
-    vector<string> parts = Split(
+    std::vector<string> parts = Split(
         value, kPathSeparator, true);
 
     for (int i = 0; i < parts.size(); i++) {
       string virtual_path;
       string disk_path;
 
       string::size_type equals_pos = parts[i].find_first_of('=');
       if (equals_pos == string::npos) {
         virtual_path = "";
         disk_path = parts[i];
       } else {
         virtual_path = parts[i].substr(0, equals_pos);
         disk_path = parts[i].substr(equals_pos + 1);
       }
 
       if (disk_path.empty()) {
         std::cerr
             << "--proto_path passed empty directory name.  (Use \".\" for "
                "current directory.)" << std::endl;
         return PARSE_ARGUMENT_FAIL;
       }
 
       // Make sure disk path exists, warn otherwise.
       if (access(disk_path.c_str(), F_OK) < 0) {
-        std::cerr << disk_path << ": warning: directory does not exist."
-                  << std::endl;
+        // Try the original path; it may have just happed to have a '=' in it.
+        if (access(parts[i].c_str(), F_OK) < 0) {
+          cerr << disk_path << ": warning: directory does not exist." << endl;
+        } else {
+          virtual_path = "";
+          disk_path = parts[i];
+        }
       }
 
       // Don't use make_pair as the old/default standard library on Solaris
       // doesn't support it without explicit template parameters, which are
       // incompatible with C++0x's make_pair.
-      proto_path_.push_back(pair<string, string>(virtual_path, disk_path));
+      proto_path_.push_back(std::pair<string, string>(virtual_path, disk_path));
     }
 
+  } else if (name == "--direct_dependencies") {
+    if (direct_dependencies_explicitly_set_) {
+      std::cerr << name << " may only be passed once. To specify multiple "
+                           "direct dependencies, pass them all as a single "
+                           "parameter separated by ':'."
+                << std::endl;
+      return PARSE_ARGUMENT_FAIL;
+    }
+
+    direct_dependencies_explicitly_set_ = true;
+    std::vector<string> direct = Split(
+        value, ":", true);
+    GOOGLE_DCHECK(direct_dependencies_.empty());
+    direct_dependencies_.insert(direct.begin(), direct.end());
+
   } else if (name == "-o" || name == "--descriptor_set_out") {
     if (!descriptor_set_name_.empty()) {
       std::cerr << name << " may only be passed once." << std::endl;
       return PARSE_ARGUMENT_FAIL;
     }
     if (value.empty()) {
       std::cerr << name << " requires a non-empty value." << std::endl;
       return PARSE_ARGUMENT_FAIL;
     }
     if (mode_ != MODE_COMPILE) {
@@ skipping 127 matching lines @@
     mode_ = MODE_PRINT;
     print_mode_ = PRINT_FREE_FIELDS;
   } else {
     // Some other flag.  Look it up in the generators list.
     const GeneratorInfo* generator_info =
         FindOrNull(generators_by_flag_name_, name);
     if (generator_info == NULL &&
         (plugin_prefix_.empty() || !HasSuffixString(name, "_out"))) {
       // Check if it's a generator option flag.
       generator_info = FindOrNull(generators_by_option_name_, name);
-      if (generator_info == NULL) {
-        std::cerr << "Unknown flag: " << name << std::endl;
-        return PARSE_ARGUMENT_FAIL;
-      } else {
+      if (generator_info != NULL) {
         string* parameters = &generator_parameters_[generator_info->flag_name];
         if (!parameters->empty()) {
           parameters->append(",");
         }
         parameters->append(value);
+      } else if (HasPrefixString(name, "--") && HasSuffixString(name, "_opt")) {
+        string* parameters =
+            &plugin_parameters_[PluginName(plugin_prefix_, name)];
+        if (!parameters->empty()) {
+          parameters->append(",");
+        }
+        parameters->append(value);
+      } else {
+        std::cerr << "Unknown flag: " << name << std::endl;
+        return PARSE_ARGUMENT_FAIL;
       }
     } else {
       // It's an output flag.  Add it to the output directives.
       if (mode_ != MODE_COMPILE) {
         std::cerr << "Cannot use --encode, --decode or print .proto info and "
                      "generate code at the same time." << std::endl;
         return PARSE_ARGUMENT_FAIL;
       }
 
       OutputDirective directive;
@@ skipping 87 matching lines @@
     // FIXME(kenton):  If the text is long enough it will wrap, which is ugly,
     //   but fixing this nicely (e.g. splitting on spaces) is probably more
     //   trouble than it's worth.
     std::cerr << "  " << iter->first << "=OUT_DIR "
               << string(19 - iter->first.size(), ' ')  // Spaces for alignment.
               << iter->second.help_text << std::endl;
   }
 }
 
 bool CommandLineInterface::GenerateOutput(
-    const vector<const FileDescriptor*>& parsed_files,
+    const std::vector<const FileDescriptor*>& parsed_files,
     const OutputDirective& output_directive,
     GeneratorContext* generator_context) {
   // Call the generator.
   string error;
   if (output_directive.generator == NULL) {
     // This is a plugin.
     GOOGLE_CHECK(HasPrefixString(output_directive.name, "--") &&
           HasSuffixString(output_directive.name, "_out"))
         << "Bad name for plugin generator: " << output_directive.name;
 
-    // Strip the "--" and "_out" and add the plugin prefix.
-    string plugin_name = plugin_prefix_ + "gen-" +
-        output_directive.name.substr(2, output_directive.name.size() - 6);
-
+    string plugin_name = PluginName(plugin_prefix_ , output_directive.name);
+    string parameters = output_directive.parameter;
+    if (!plugin_parameters_[plugin_name].empty()) {
+      if (!parameters.empty()) {
+        parameters.append(",");
+      }
+      parameters.append(plugin_parameters_[plugin_name]);
+    }
     if (!GeneratePluginOutput(parsed_files, plugin_name,
-                              output_directive.parameter,
+                              parameters,
                               generator_context, &error)) {
       std::cerr << output_directive.name << ": " << error << std::endl;
       return false;
     }
   } else {
     // Regular generator.
     string parameters = output_directive.parameter;
     if (!generator_parameters_[output_directive.name].empty()) {
       if (!parameters.empty()) {
         parameters.append(",");
       }
       parameters.append(generator_parameters_[output_directive.name]);
     }
-    if (output_directive.generator->HasGenerateAll()) {
-      if (!output_directive.generator->GenerateAll(
-          parsed_files, parameters, generator_context, &error)) {
-          // Generator returned an error.
-          std::cerr << output_directive.name << ": "
-                    << ": " << error << std::endl;
-          return false;
-      }
-    } else {
-      for (int i = 0; i < parsed_files.size(); i++) {
-        if (!output_directive.generator->Generate(parsed_files[i], parameters,
-                                                  generator_context, &error)) {
-          // Generator returned an error.
-          std::cerr << output_directive.name << ": " << parsed_files[i]->name()
-                    << ": " << error << std::endl;
-          return false;
-        }
-      }
+    if (!output_directive.generator->GenerateAll(
+        parsed_files, parameters, generator_context, &error)) {
+      // Generator returned an error.
+      std::cerr << output_directive.name << ": " << error << std::endl;
+      return false;
     }
   }
 
   return true;
 }
 
 bool CommandLineInterface::GenerateDependencyManifestFile(
-    const vector<const FileDescriptor*>& parsed_files,
+    const std::vector<const FileDescriptor*>& parsed_files,
     const GeneratorContextMap& output_directories,
     DiskSourceTree* source_tree) {
   FileDescriptorSet file_set;
 
-  set<const FileDescriptor*> already_seen;
+  std::set<const FileDescriptor*> already_seen;
   for (int i = 0; i < parsed_files.size(); i++) {
     GetTransitiveDependencies(parsed_files[i],
                               false,
                               false,
                               &already_seen,
                               file_set.mutable_file());
   }
 
-  vector<string> output_filenames;
+  std::vector<string> output_filenames;
   for (GeneratorContextMap::const_iterator iter = output_directories.begin();
        iter != output_directories.end(); ++iter) {
     const string& location = iter->first;
     GeneratorContextImpl* directory = iter->second;
-    vector<string> relative_output_filenames;
+    std::vector<string> relative_output_filenames;
     directory->GetOutputFilenames(&relative_output_filenames);
     for (int i = 0; i < relative_output_filenames.size(); i++) {
       string output_filename = location + relative_output_filenames[i];
       if (output_filename.compare(0, 2, "./") == 0) {
         output_filename = output_filename.substr(2);
       }
       output_filenames.push_back(output_filename);
     }
   }
 
@@ skipping 32 matching lines @@
       std::cerr << "Unable to identify path for file " << virtual_file
                 << std::endl;
       return false;
     }
   }
 
   return true;
 }
 
 bool CommandLineInterface::GeneratePluginOutput(
-    const vector<const FileDescriptor*>& parsed_files,
+    const std::vector<const FileDescriptor*>& parsed_files,
     const string& plugin_name,
     const string& parameter,
     GeneratorContext* generator_context,
     string* error) {
   CodeGeneratorRequest request;
   CodeGeneratorResponse response;
 
   // Build the request.
   if (!parameter.empty()) {
     request.set_parameter(parameter);
   }
 
-  set<const FileDescriptor*> already_seen;
+  std::set<const FileDescriptor*> already_seen;
   for (int i = 0; i < parsed_files.size(); i++) {
     request.add_file_to_generate(parsed_files[i]->name());
     GetTransitiveDependencies(parsed_files[i],
                               true,  // Include json_name for plugins.
                               true,  // Include source code info.
                               &already_seen, request.mutable_proto_file());
   }
 
+  google::protobuf::compiler::Version* version =
+      request.mutable_compiler_version();
+  version->set_major(GOOGLE_PROTOBUF_VERSION / 1000000);
+  version->set_minor(GOOGLE_PROTOBUF_VERSION / 1000 % 1000);
+  version->set_patch(GOOGLE_PROTOBUF_VERSION % 1000);
+  version->set_suffix(GOOGLE_PROTOBUF_VERSION_SUFFIX);
+
   // Invoke the plugin.
   Subprocess subprocess;
 
   if (plugins_.count(plugin_name) > 0) {
     subprocess.Start(plugins_[plugin_name], Subprocess::EXACT_NAME);
   } else {
     subprocess.Start(plugin_name, Subprocess::SEARCH_PATH);
   }
 
   string communicate_error;
@@ skipping 101 matching lines @@
     if (!TextFormat::Print(*message, &out)) {
       std::cerr << "output: I/O error." << std::endl;
       return false;
     }
   }
 
   return true;
 }
 
 bool CommandLineInterface::WriteDescriptorSet(
-    const vector<const FileDescriptor*> parsed_files) {
+    const std::vector<const FileDescriptor*> parsed_files) {
   FileDescriptorSet file_set;
 
   if (imports_in_descriptor_set_) {
-    set<const FileDescriptor*> already_seen;
+    std::set<const FileDescriptor*> already_seen;
     for (int i = 0; i < parsed_files.size(); i++) {
       GetTransitiveDependencies(parsed_files[i],
                                 true,  // Include json_name
                                 source_info_in_descriptor_set_,
                                 &already_seen, file_set.mutable_file());
     }
   } else {
-    set<const FileDescriptor*> already_seen;
+    std::set<const FileDescriptor*> already_seen;
     for (int i = 0; i < parsed_files.size(); i++) {
       if (!already_seen.insert(parsed_files[i]).second) {
         continue;
       }
       FileDescriptorProto* file_proto = file_set.add_file();
       parsed_files[i]->CopyTo(file_proto);
       parsed_files[i]->CopyJsonNameTo(file_proto);
       if (source_info_in_descriptor_set_) {
         parsed_files[i]->CopySourceCodeInfoTo(file_proto);
       }
@@ skipping 24 matching lines @@
     return false;
   }
 
   return true;
 }
 
 void CommandLineInterface::GetTransitiveDependencies(
     const FileDescriptor* file,
     bool include_json_name,
     bool include_source_code_info,
-    set<const FileDescriptor*>* already_seen,
+    std::set<const FileDescriptor*>* already_seen,
     RepeatedPtrField<FileDescriptorProto>* output) {
   if (!already_seen->insert(file).second) {
     // Already saw this file.  Skip.
     return;
   }
 
   // Add all dependencies.
   for (int i = 0; i < file->dependency_count(); i++) {
     GetTransitiveDependencies(file->dependency(i),
                               include_json_name,
@@ skipping 38 matching lines @@
 //     message NestedBaz {}
 //   }
 // }
 //
 // In this case, Bar, Quz and NestedBaz will be added into the nested types.
 // Since free field numbers of group types will not be printed, this makes sure
 // the nested message types in groups will not be dropped. The nested_messages
 // parameter will contain the direct children (when groups are ignored in the
 // tree) of the given descriptor for the caller to traverse. The declaration
 // order of the nested messages is also preserved.
-typedef pair<int, int> FieldRange;
-void GatherOccupiedFieldRanges(const Descriptor* descriptor,
-                               set<FieldRange>* ranges,
-                               vector<const Descriptor*>* nested_messages) {
-  set<const Descriptor*> groups;
+typedef std::pair<int, int> FieldRange;
+void GatherOccupiedFieldRanges(
+    const Descriptor* descriptor, std::set<FieldRange>* ranges,
+    std::vector<const Descriptor*>* nested_messages) {
+  std::set<const Descriptor*> groups;
   for (int i = 0; i < descriptor->field_count(); ++i) {
     const FieldDescriptor* fd = descriptor->field(i);
     ranges->insert(FieldRange(fd->number(), fd->number() + 1));
     if (fd->type() == FieldDescriptor::TYPE_GROUP) {
       groups.insert(fd->message_type());
     }
   }
   for (int i = 0; i < descriptor->extension_range_count(); ++i) {
     ranges->insert(FieldRange(descriptor->extension_range(i)->start,
                               descriptor->extension_range(i)->end));
@@ skipping 11 matching lines @@
     } else {
       nested_messages->push_back(nested_desc);
     }
   }
 }
 
 // Utility function for PrintFreeFieldNumbers.
 // Actually prints the formatted free field numbers for given message name and
 // occupied ranges.
 void FormatFreeFieldNumbers(const string& name,
-                            const set<FieldRange>& ranges) {
+                            const std::set<FieldRange>& ranges) {
   string output;
   StringAppendF(&output, "%-35s free:", name.c_str());
   int next_free_number = 1;
-  for (set<FieldRange>::const_iterator i = ranges.begin();
+  for (std::set<FieldRange>::const_iterator i = ranges.begin();
        i != ranges.end(); ++i) {
     // This happens when groups re-use parent field numbers, in which
     // case we skip the FieldRange entirely.
     if (next_free_number >= i->second) continue;
 
     if (next_free_number < i->first) {
       if (next_free_number + 1 == i->first) {
         // Singleton
         StringAppendF(&output, " %d", next_free_number);
       } else {
         // Range
         StringAppendF(&output, " %d-%d", next_free_number, i->first - 1);
       }
     }
     next_free_number = i->second;
   }
   if (next_free_number <= FieldDescriptor::kMaxNumber) {
     StringAppendF(&output, " %d-INF", next_free_number);
   }
   std::cout << output << std::endl;
 }
 
 }  // namespace
 
 void CommandLineInterface::PrintFreeFieldNumbers(
     const Descriptor* descriptor) {
-  set<FieldRange> ranges;
-  vector<const Descriptor*> nested_messages;
+  std::set<FieldRange> ranges;
+  std::vector<const Descriptor*> nested_messages;
   GatherOccupiedFieldRanges(descriptor, &ranges, &nested_messages);
 
   for (int i = 0; i < nested_messages.size(); ++i) {
     PrintFreeFieldNumbers(nested_messages[i]);
   }
   FormatFreeFieldNumbers(descriptor->full_name(), ranges);
 }
 
 
 
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google