PageRenderTime 30ms CodeModel.GetById 11ms app.highlight 14ms RepoModel.GetById 1ms app.codeStats 1ms

/thirdparty/breakpad/third_party/protobuf/protobuf/src/google/protobuf/compiler/command_line_interface.h

http://github.com/tomahawk-player/tomahawk
C++ Header | 318 lines | 100 code | 46 blank | 172 comment | 0 complexity | 025a14a72030dcac6bfb8ac546a4b0e0 MD5 | raw file
  1// Protocol Buffers - Google's data interchange format
  2// Copyright 2008 Google Inc.  All rights reserved.
  3// http://code.google.com/p/protobuf/
  4//
  5// Redistribution and use in source and binary forms, with or without
  6// modification, are permitted provided that the following conditions are
  7// met:
  8//
  9//     * Redistributions of source code must retain the above copyright
 10// notice, this list of conditions and the following disclaimer.
 11//     * Redistributions in binary form must reproduce the above
 12// copyright notice, this list of conditions and the following disclaimer
 13// in the documentation and/or other materials provided with the
 14// distribution.
 15//     * Neither the name of Google Inc. nor the names of its
 16// contributors may be used to endorse or promote products derived from
 17// this software without specific prior written permission.
 18//
 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 30
 31// Author: kenton@google.com (Kenton Varda)
 32//  Based on original Protocol Buffers design by
 33//  Sanjay Ghemawat, Jeff Dean, and others.
 34//
 35// Implements the Protocol Compiler front-end such that it may be reused by
 36// custom compilers written to support other languages.
 37
 38#ifndef GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
 39#define GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
 40
 41#include <google/protobuf/stubs/common.h>
 42#include <string>
 43#include <vector>
 44#include <map>
 45#include <set>
 46#include <utility>
 47
 48namespace google {
 49namespace protobuf {
 50
 51class FileDescriptor;        // descriptor.h
 52class DescriptorPool;        // descriptor.h
 53class FileDescriptorProto;   // descriptor.pb.h
 54template<typename T> class RepeatedPtrField;  // repeated_field.h
 55
 56namespace compiler {
 57
 58class CodeGenerator;        // code_generator.h
 59class GeneratorContext;      // code_generator.h
 60class DiskSourceTree;       // importer.h
 61
 62// This class implements the command-line interface to the protocol compiler.
 63// It is designed to make it very easy to create a custom protocol compiler
 64// supporting the languages of your choice.  For example, if you wanted to
 65// create a custom protocol compiler binary which includes both the regular
 66// C++ support plus support for your own custom output "Foo", you would
 67// write a class "FooGenerator" which implements the CodeGenerator interface,
 68// then write a main() procedure like this:
 69//
 70//   int main(int argc, char* argv[]) {
 71//     google::protobuf::compiler::CommandLineInterface cli;
 72//
 73//     // Support generation of C++ source and headers.
 74//     google::protobuf::compiler::cpp::CppGenerator cpp_generator;
 75//     cli.RegisterGenerator("--cpp_out", &cpp_generator,
 76//       "Generate C++ source and header.");
 77//
 78//     // Support generation of Foo code.
 79//     FooGenerator foo_generator;
 80//     cli.RegisterGenerator("--foo_out", &foo_generator,
 81//       "Generate Foo file.");
 82//
 83//     return cli.Run(argc, argv);
 84//   }
 85//
 86// The compiler is invoked with syntax like:
 87//   protoc --cpp_out=outdir --foo_out=outdir --proto_path=src src/foo.proto
 88//
 89// For a full description of the command-line syntax, invoke it with --help.
 90class LIBPROTOC_EXPORT CommandLineInterface {
 91 public:
 92  CommandLineInterface();
 93  ~CommandLineInterface();
 94
 95  // Register a code generator for a language.
 96  //
 97  // Parameters:
 98  // * flag_name: The command-line flag used to specify an output file of
 99  //   this type.  The name must start with a '-'.  If the name is longer
100  //   than one letter, it must start with two '-'s.
101  // * generator: The CodeGenerator which will be called to generate files
102  //   of this type.
103  // * help_text: Text describing this flag in the --help output.
104  //
105  // Some generators accept extra parameters.  You can specify this parameter
106  // on the command-line by placing it before the output directory, separated
107  // by a colon:
108  //   protoc --foo_out=enable_bar:outdir
109  // The text before the colon is passed to CodeGenerator::Generate() as the
110  // "parameter".
111  void RegisterGenerator(const string& flag_name,
112                         CodeGenerator* generator,
113                         const string& help_text);
114
115  // Enables "plugins".  In this mode, if a command-line flag ends with "_out"
116  // but does not match any registered generator, the compiler will attempt to
117  // find a "plugin" to implement the generator.  Plugins are just executables.
118  // They should live somewhere in the PATH.
119  //
120  // The compiler determines the executable name to search for by concatenating
121  // exe_name_prefix with the unrecognized flag name, removing "_out".  So, for
122  // example, if exe_name_prefix is "protoc-" and you pass the flag --foo_out,
123  // the compiler will try to run the program "protoc-foo".
124  //
125  // The plugin program should implement the following usage:
126  //   plugin [--out=OUTDIR] [--parameter=PARAMETER] PROTO_FILES < DESCRIPTORS
127  // --out indicates the output directory (as passed to the --foo_out
128  // parameter); if omitted, the current directory should be used.  --parameter
129  // gives the generator parameter, if any was provided.  The PROTO_FILES list
130  // the .proto files which were given on the compiler command-line; these are
131  // the files for which the plugin is expected to generate output code.
132  // Finally, DESCRIPTORS is an encoded FileDescriptorSet (as defined in
133  // descriptor.proto).  This is piped to the plugin's stdin.  The set will
134  // include descriptors for all the files listed in PROTO_FILES as well as
135  // all files that they import.  The plugin MUST NOT attempt to read the
136  // PROTO_FILES directly -- it must use the FileDescriptorSet.
137  //
138  // The plugin should generate whatever files are necessary, as code generators
139  // normally do.  It should write the names of all files it generates to
140  // stdout.  The names should be relative to the output directory, NOT absolute
141  // names or relative to the current directory.  If any errors occur, error
142  // messages should be written to stderr.  If an error is fatal, the plugin
143  // should exit with a non-zero exit code.
144  void AllowPlugins(const string& exe_name_prefix);
145
146  // Run the Protocol Compiler with the given command-line parameters.
147  // Returns the error code which should be returned by main().
148  //
149  // It may not be safe to call Run() in a multi-threaded environment because
150  // it calls strerror().  I'm not sure why you'd want to do this anyway.
151  int Run(int argc, const char* const argv[]);
152
153  // Call SetInputsAreCwdRelative(true) if the input files given on the command
154  // line should be interpreted relative to the proto import path specified
155  // using --proto_path or -I flags.  Otherwise, input file names will be
156  // interpreted relative to the current working directory (or as absolute
157  // paths if they start with '/'), though they must still reside inside
158  // a directory given by --proto_path or the compiler will fail.  The latter
159  // mode is generally more intuitive and easier to use, especially e.g. when
160  // defining implicit rules in Makefiles.
161  void SetInputsAreProtoPathRelative(bool enable) {
162    inputs_are_proto_path_relative_ = enable;
163  }
164
165  // Provides some text which will be printed when the --version flag is
166  // used.  The version of libprotoc will also be printed on the next line
167  // after this text.
168  void SetVersionInfo(const string& text) {
169    version_info_ = text;
170  }
171
172
173 private:
174  // -----------------------------------------------------------------
175
176  class ErrorPrinter;
177  class GeneratorContextImpl;
178  class MemoryOutputStream;
179
180  // Clear state from previous Run().
181  void Clear();
182
183  // Remaps each file in input_files_ so that it is relative to one of the
184  // directories in proto_path_.  Returns false if an error occurred.  This
185  // is only used if inputs_are_proto_path_relative_ is false.
186  bool MakeInputsBeProtoPathRelative(
187    DiskSourceTree* source_tree);
188
189  // Parse all command-line arguments.
190  bool ParseArguments(int argc, const char* const argv[]);
191
192  // Parses a command-line argument into a name/value pair.  Returns
193  // true if the next argument in the argv should be used as the value,
194  // false otherwise.
195  //
196  // Exmaples:
197  //   "-Isrc/protos" ->
198  //     name = "-I", value = "src/protos"
199  //   "--cpp_out=src/foo.pb2.cc" ->
200  //     name = "--cpp_out", value = "src/foo.pb2.cc"
201  //   "foo.proto" ->
202  //     name = "", value = "foo.proto"
203  bool ParseArgument(const char* arg, string* name, string* value);
204
205  // Interprets arguments parsed with ParseArgument.
206  bool InterpretArgument(const string& name, const string& value);
207
208  // Print the --help text to stderr.
209  void PrintHelpText();
210
211  // Generate the given output file from the given input.
212  struct OutputDirective;  // see below
213  bool GenerateOutput(const vector<const FileDescriptor*>& parsed_files,
214                      const OutputDirective& output_directive,
215                      GeneratorContext* generator_context);
216  bool GeneratePluginOutput(const vector<const FileDescriptor*>& parsed_files,
217                            const string& plugin_name,
218                            const string& parameter,
219                            GeneratorContext* generator_context,
220                            string* error);
221
222  // Implements --encode and --decode.
223  bool EncodeOrDecode(const DescriptorPool* pool);
224
225  // Implements the --descriptor_set_out option.
226  bool WriteDescriptorSet(const vector<const FileDescriptor*> parsed_files);
227
228  // Get all transitive dependencies of the given file (including the file
229  // itself), adding them to the given list of FileDescriptorProtos.  The
230  // protos will be ordered such that every file is listed before any file that
231  // depends on it, so that you can call DescriptorPool::BuildFile() on them
232  // in order.  Any files in *already_seen will not be added, and each file
233  // added will be inserted into *already_seen.
234  static void GetTransitiveDependencies(
235      const FileDescriptor* file,
236      set<const FileDescriptor*>* already_seen,
237      RepeatedPtrField<FileDescriptorProto>* output);
238
239  // -----------------------------------------------------------------
240
241  // The name of the executable as invoked (i.e. argv[0]).
242  string executable_name_;
243
244  // Version info set with SetVersionInfo().
245  string version_info_;
246
247  // Map from flag names to registered generators.
248  struct GeneratorInfo {
249    CodeGenerator* generator;
250    string help_text;
251  };
252  typedef map<string, GeneratorInfo> GeneratorMap;
253  GeneratorMap generators_;
254
255  // See AllowPlugins().  If this is empty, plugins aren't allowed.
256  string plugin_prefix_;
257
258  // Maps specific plugin names to files.  When executing a plugin, this map
259  // is searched first to find the plugin executable.  If not found here, the
260  // PATH (or other OS-specific search strategy) is searched.
261  map<string, string> plugins_;
262
263  // Stuff parsed from command line.
264  enum Mode {
265    MODE_COMPILE,  // Normal mode:  parse .proto files and compile them.
266    MODE_ENCODE,   // --encode:  read text from stdin, write binary to stdout.
267    MODE_DECODE    // --decode:  read binary from stdin, write text to stdout.
268  };
269
270  Mode mode_;
271
272  enum ErrorFormat {
273    ERROR_FORMAT_GCC,   // GCC error output format (default).
274    ERROR_FORMAT_MSVS   // Visual Studio output (--error_format=msvs).
275  };
276
277  ErrorFormat error_format_;
278
279  vector<pair<string, string> > proto_path_;  // Search path for proto files.
280  vector<string> input_files_;                // Names of the input proto files.
281
282  // output_directives_ lists all the files we are supposed to output and what
283  // generator to use for each.
284  struct OutputDirective {
285    string name;                // E.g. "--foo_out"
286    CodeGenerator* generator;   // NULL for plugins
287    string parameter;
288    string output_location;
289  };
290  vector<OutputDirective> output_directives_;
291
292  // When using --encode or --decode, this names the type we are encoding or
293  // decoding.  (Empty string indicates --decode_raw.)
294  string codec_type_;
295
296  // If --descriptor_set_out was given, this is the filename to which the
297  // FileDescriptorSet should be written.  Otherwise, empty.
298  string descriptor_set_name_;
299
300  // True if --include_imports was given, meaning that we should
301  // write all transitive dependencies to the DescriptorSet.  Otherwise, only
302  // the .proto files listed on the command-line are added.
303  bool imports_in_descriptor_set_;
304
305  // Was the --disallow_services flag used?
306  bool disallow_services_;
307
308  // See SetInputsAreProtoPathRelative().
309  bool inputs_are_proto_path_relative_;
310
311  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CommandLineInterface);
312};
313
314}  // namespace compiler
315}  // namespace protobuf
316
317}  // namespace google
318#endif  // GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__