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

http://github.com/tomahawk-player/tomahawk · C++ Header · 303 lines · 120 code · 42 blank · 141 comment · 0 complexity · 01b4af97fab37556429d87bb705eac06 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. // Author: kenton@google.com (Kenton Varda)
  31. // Based on original Protocol Buffers design by
  32. // Sanjay Ghemawat, Jeff Dean, and others.
  33. //
  34. // This file is the public interface to the .proto file parser.
  35. #ifndef GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
  36. #define GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
  37. #include <string>
  38. #include <vector>
  39. #include <set>
  40. #include <utility>
  41. #include <google/protobuf/descriptor.h>
  42. #include <google/protobuf/descriptor_database.h>
  43. #include <google/protobuf/compiler/parser.h>
  44. namespace google {
  45. namespace protobuf {
  46. namespace io { class ZeroCopyInputStream; }
  47. namespace compiler {
  48. // Defined in this file.
  49. class Importer;
  50. class MultiFileErrorCollector;
  51. class SourceTree;
  52. class DiskSourceTree;
  53. // TODO(kenton): Move all SourceTree stuff to a separate file?
  54. // An implementation of DescriptorDatabase which loads files from a SourceTree
  55. // and parses them.
  56. //
  57. // Note: This class is not thread-safe since it maintains a table of source
  58. // code locations for error reporting. However, when a DescriptorPool wraps
  59. // a DescriptorDatabase, it uses mutex locking to make sure only one method
  60. // of the database is called at a time, even if the DescriptorPool is used
  61. // from multiple threads. Therefore, there is only a problem if you create
  62. // multiple DescriptorPools wrapping the same SourceTreeDescriptorDatabase
  63. // and use them from multiple threads.
  64. //
  65. // Note: This class does not implement FindFileContainingSymbol() or
  66. // FindFileContainingExtension(); these will always return false.
  67. class LIBPROTOBUF_EXPORT SourceTreeDescriptorDatabase : public DescriptorDatabase {
  68. public:
  69. SourceTreeDescriptorDatabase(SourceTree* source_tree);
  70. ~SourceTreeDescriptorDatabase();
  71. // Instructs the SourceTreeDescriptorDatabase to report any parse errors
  72. // to the given MultiFileErrorCollector. This should be called before
  73. // parsing. error_collector must remain valid until either this method
  74. // is called again or the SourceTreeDescriptorDatabase is destroyed.
  75. void RecordErrorsTo(MultiFileErrorCollector* error_collector) {
  76. error_collector_ = error_collector;
  77. }
  78. // Gets a DescriptorPool::ErrorCollector which records errors to the
  79. // MultiFileErrorCollector specified with RecordErrorsTo(). This collector
  80. // has the ability to determine exact line and column numbers of errors
  81. // from the information given to it by the DescriptorPool.
  82. DescriptorPool::ErrorCollector* GetValidationErrorCollector() {
  83. using_validation_error_collector_ = true;
  84. return &validation_error_collector_;
  85. }
  86. // implements DescriptorDatabase -----------------------------------
  87. bool FindFileByName(const string& filename, FileDescriptorProto* output);
  88. bool FindFileContainingSymbol(const string& symbol_name,
  89. FileDescriptorProto* output);
  90. bool FindFileContainingExtension(const string& containing_type,
  91. int field_number,
  92. FileDescriptorProto* output);
  93. private:
  94. class SingleFileErrorCollector;
  95. SourceTree* source_tree_;
  96. MultiFileErrorCollector* error_collector_;
  97. class LIBPROTOBUF_EXPORT ValidationErrorCollector : public DescriptorPool::ErrorCollector {
  98. public:
  99. ValidationErrorCollector(SourceTreeDescriptorDatabase* owner);
  100. ~ValidationErrorCollector();
  101. // implements ErrorCollector ---------------------------------------
  102. void AddError(const string& filename,
  103. const string& element_name,
  104. const Message* descriptor,
  105. ErrorLocation location,
  106. const string& message);
  107. private:
  108. SourceTreeDescriptorDatabase* owner_;
  109. };
  110. friend class ValidationErrorCollector;
  111. bool using_validation_error_collector_;
  112. SourceLocationTable source_locations_;
  113. ValidationErrorCollector validation_error_collector_;
  114. };
  115. // Simple interface for parsing .proto files. This wraps the process
  116. // of opening the file, parsing it with a Parser, recursively parsing all its
  117. // imports, and then cross-linking the results to produce a FileDescriptor.
  118. //
  119. // This is really just a thin wrapper around SourceTreeDescriptorDatabase.
  120. // You may find that SourceTreeDescriptorDatabase is more flexible.
  121. //
  122. // TODO(kenton): I feel like this class is not well-named.
  123. class LIBPROTOBUF_EXPORT Importer {
  124. public:
  125. Importer(SourceTree* source_tree,
  126. MultiFileErrorCollector* error_collector);
  127. ~Importer();
  128. // Import the given file and build a FileDescriptor representing it. If
  129. // the file is already in the DescriptorPool, the existing FileDescriptor
  130. // will be returned. The FileDescriptor is property of the DescriptorPool,
  131. // and will remain valid until it is destroyed. If any errors occur, they
  132. // will be reported using the error collector and Import() will return NULL.
  133. //
  134. // A particular Importer object will only report errors for a particular
  135. // file once. All future attempts to import the same file will return NULL
  136. // without reporting any errors. The idea is that you might want to import
  137. // a lot of files without seeing the same errors over and over again. If
  138. // you want to see errors for the same files repeatedly, you can use a
  139. // separate Importer object to import each one (but use the same
  140. // DescriptorPool so that they can be cross-linked).
  141. const FileDescriptor* Import(const string& filename);
  142. // The DescriptorPool in which all imported FileDescriptors and their
  143. // contents are stored.
  144. inline const DescriptorPool* pool() const {
  145. return &pool_;
  146. }
  147. private:
  148. SourceTreeDescriptorDatabase database_;
  149. DescriptorPool pool_;
  150. GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Importer);
  151. };
  152. // If the importer encounters problems while trying to import the proto files,
  153. // it reports them to a MultiFileErrorCollector.
  154. class LIBPROTOBUF_EXPORT MultiFileErrorCollector {
  155. public:
  156. inline MultiFileErrorCollector() {}
  157. virtual ~MultiFileErrorCollector();
  158. // Line and column numbers are zero-based. A line number of -1 indicates
  159. // an error with the entire file (e.g. "not found").
  160. virtual void AddError(const string& filename, int line, int column,
  161. const string& message) = 0;
  162. private:
  163. GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MultiFileErrorCollector);
  164. };
  165. // Abstract interface which represents a directory tree containing proto files.
  166. // Used by the default implementation of Importer to resolve import statements
  167. // Most users will probably want to use the DiskSourceTree implementation,
  168. // below.
  169. class LIBPROTOBUF_EXPORT SourceTree {
  170. public:
  171. inline SourceTree() {}
  172. virtual ~SourceTree();
  173. // Open the given file and return a stream that reads it, or NULL if not
  174. // found. The caller takes ownership of the returned object. The filename
  175. // must be a path relative to the root of the source tree and must not
  176. // contain "." or ".." components.
  177. virtual io::ZeroCopyInputStream* Open(const string& filename) = 0;
  178. private:
  179. GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SourceTree);
  180. };
  181. // An implementation of SourceTree which loads files from locations on disk.
  182. // Multiple mappings can be set up to map locations in the DiskSourceTree to
  183. // locations in the physical filesystem.
  184. class LIBPROTOBUF_EXPORT DiskSourceTree : public SourceTree {
  185. public:
  186. DiskSourceTree();
  187. ~DiskSourceTree();
  188. // Map a path on disk to a location in the SourceTree. The path may be
  189. // either a file or a directory. If it is a directory, the entire tree
  190. // under it will be mapped to the given virtual location. To map a directory
  191. // to the root of the source tree, pass an empty string for virtual_path.
  192. //
  193. // If multiple mapped paths apply when opening a file, they will be searched
  194. // in order. For example, if you do:
  195. // MapPath("bar", "foo/bar");
  196. // MapPath("", "baz");
  197. // and then you do:
  198. // Open("bar/qux");
  199. // the DiskSourceTree will first try to open foo/bar/qux, then baz/bar/qux,
  200. // returning the first one that opens successfuly.
  201. //
  202. // disk_path may be an absolute path or relative to the current directory,
  203. // just like a path you'd pass to open().
  204. void MapPath(const string& virtual_path, const string& disk_path);
  205. // Return type for DiskFileToVirtualFile().
  206. enum DiskFileToVirtualFileResult {
  207. SUCCESS,
  208. SHADOWED,
  209. CANNOT_OPEN,
  210. NO_MAPPING
  211. };
  212. // Given a path to a file on disk, find a virtual path mapping to that
  213. // file. The first mapping created with MapPath() whose disk_path contains
  214. // the filename is used. However, that virtual path may not actually be
  215. // usable to open the given file. Possible return values are:
  216. // * SUCCESS: The mapping was found. *virtual_file is filled in so that
  217. // calling Open(*virtual_file) will open the file named by disk_file.
  218. // * SHADOWED: A mapping was found, but using Open() to open this virtual
  219. // path will end up returning some different file. This is because some
  220. // other mapping with a higher precedence also matches this virtual path
  221. // and maps it to a different file that exists on disk. *virtual_file
  222. // is filled in as it would be in the SUCCESS case. *shadowing_disk_file
  223. // is filled in with the disk path of the file which would be opened if
  224. // you were to call Open(*virtual_file).
  225. // * CANNOT_OPEN: The mapping was found and was not shadowed, but the
  226. // file specified cannot be opened. When this value is returned,
  227. // errno will indicate the reason the file cannot be opened. *virtual_file
  228. // will be set to the virtual path as in the SUCCESS case, even though
  229. // it is not useful.
  230. // * NO_MAPPING: Indicates that no mapping was found which contains this
  231. // file.
  232. DiskFileToVirtualFileResult
  233. DiskFileToVirtualFile(const string& disk_file,
  234. string* virtual_file,
  235. string* shadowing_disk_file);
  236. // Given a virtual path, find the path to the file on disk.
  237. // Return true and update disk_file with the on-disk path if the file exists.
  238. // Return false and leave disk_file untouched if the file doesn't exist.
  239. bool VirtualFileToDiskFile(const string& virtual_file, string* disk_file);
  240. // implements SourceTree -------------------------------------------
  241. io::ZeroCopyInputStream* Open(const string& filename);
  242. private:
  243. struct Mapping {
  244. string virtual_path;
  245. string disk_path;
  246. inline Mapping(const string& virtual_path, const string& disk_path)
  247. : virtual_path(virtual_path), disk_path(disk_path) {}
  248. };
  249. vector<Mapping> mappings_;
  250. // Like Open(), but returns the on-disk path in disk_file if disk_file is
  251. // non-NULL and the file could be successfully opened.
  252. io::ZeroCopyInputStream* OpenVirtualFile(const string& virtual_file,
  253. string* disk_file);
  254. // Like Open() but given the actual on-disk path.
  255. io::ZeroCopyInputStream* OpenDiskFile(const string& filename);
  256. GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DiskSourceTree);
  257. };
  258. } // namespace compiler
  259. } // namespace protobuf
  260. } // namespace google
  261. #endif // GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__