ADD_SUBDIRECTORY(sqlite3)

ADD_SUBDIRECTORY(protobuf)

add_subdirectory(libprotobuf)

add_subdirectory(libprotoc)

add_subdirectory(protoc)

cmake_minimum_required(VERSION 2.6)

FILE(GLOB SRC google/protobuf/*.cc google/protobuf/*.h google/protobuf/io/*.cc google/protobuf/io/*.h google/protobuf/stubs/*.cc google/protobuf/stubs/*.h google/protobuf/compiler/*.cc google/protobuf/compiler/*.h)

include_directories(.)

ADD_LIBRARY(libprotobuf STATIC ${HEADERS} ${SRC})

INSTALL(TARGETS libprotobuf LIBRARY DESTINATION lib ARCHIVE DESTINATION lib COMPONENT libraries)

/* protobuf config.h for MSVC.  On other platforms, this is generated

 * automatically by autoheader / autoconf / configure. */

/* the location of <hash_map> */

#define HASH_MAP_H <hash_map>

/* the namespace of hash_map/hash_set */

// Apparently Microsoft decided to move hash_map *back* to the std namespace

// in MSVC 2010:

//   http://blogs.msdn.com/vcblog/archive/2009/05/25/stl-breaking-changes-in-visual-studio-2010-beta-1.aspx

// TODO(kenton):  Use unordered_map instead, which is available in MSVC 2010.

#if _MSC_VER < 1310 || _MSC_VER >= 1600

#define HASH_NAMESPACE std

#else

#define HASH_NAMESPACE stdext

#endif

/* the location of <hash_set> */

#define HASH_SET_H <hash_set>

/* define if the compiler has hash_map */

#define HAVE_HASH_MAP 1

/* define if the compiler has hash_set */

#define HAVE_HASH_SET 1

/* define if you want to use zlib.  See readme.txt for additional

 * requirements. */

// #define HAVE_ZLIB 1

// Protocol Buffers - Google's data interchange format

// Copyright 2008 Google Inc.  All rights reserved.

// http://code.google.com/p/protobuf/

//

// 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.

// Author: kenton@google.com (Kenton Varda)

//  Based on original Protocol Buffers design by

//  Sanjay Ghemawat, Jeff Dean, and others.

#ifdef _MSC_VER

#include <io.h>

#else

#include <unistd.h>

#endif

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <errno.h>

#include <algorithm>

#include <google/protobuf/compiler/importer.h>

#include <google/protobuf/compiler/parser.h>

#include <google/protobuf/io/tokenizer.h>

#include <google/protobuf/io/zero_copy_stream_impl.h>

#include <google/protobuf/stubs/strutil.h>

namespace google {

namespace protobuf {

namespace compiler {

#ifdef _WIN32

#ifndef F_OK

#define F_OK 00  // not defined by MSVC for whatever reason

#endif

#include <ctype.h>

#endif

// Returns true if the text looks like a Windows-style absolute path, starting

// with a drive letter.  Example:  "C:\foo".  TODO(kenton):  Share this with

// copy in command_line_interface.cc?

static bool IsWindowsAbsolutePath(const string& text) {

#if defined(_WIN32) || defined(__CYGWIN__)

  return text.size() >= 3 && text[1] == ':' &&

         isalpha(text[0]) &&

         (text[2] == '/' || text[2] == '\\') &&

         text.find_last_of(':') == 1;

#else

  return false;

#endif

}

MultiFileErrorCollector::~MultiFileErrorCollector() {}

// This class serves two purposes:

// - It implements the ErrorCollector interface (used by Tokenizer and Parser)

//   in terms of MultiFileErrorCollector, using a particular filename.

// - It lets us check if any errors have occurred.

class SourceTreeDescriptorDatabase::SingleFileErrorCollector

    : public io::ErrorCollector {

 public:

  SingleFileErrorCollector(const string& filename,

                           MultiFileErrorCollector* multi_file_error_collector)

    : filename_(filename),

      multi_file_error_collector_(multi_file_error_collector),

      had_errors_(false) {}

  ~SingleFileErrorCollector() {}

  bool had_errors() { return had_errors_; }

  // implements ErrorCollector ---------------------------------------

  void AddError(int line, int column, const string& message) {

    if (multi_file_error_collector_ != NULL) {

      multi_file_error_collector_->AddError(filename_, line, column, message);

    }

    had_errors_ = true;

  }

 private:

  string filename_;

  MultiFileErrorCollector* multi_file_error_collector_;

  bool had_errors_;

};

// ===================================================================

SourceTreeDescriptorDatabase::SourceTreeDescriptorDatabase(

    SourceTree* source_tree)

  : source_tree_(source_tree),

    error_collector_(NULL),

    using_validation_error_collector_(false),

    validation_error_collector_(this) {}

SourceTreeDescriptorDatabase::~SourceTreeDescriptorDatabase() {}

bool SourceTreeDescriptorDatabase::FindFileByName(

    const string& filename, FileDescriptorProto* output) {

  scoped_ptr<io::ZeroCopyInputStream> input(source_tree_->Open(filename));

  if (input == NULL) {

    if (error_collector_ != NULL) {

      error_collector_->AddError(filename, -1, 0, "File not found.");

    }

    return false;

  }

  // Set up the tokenizer and parser.

  SingleFileErrorCollector file_error_collector(filename, error_collector_);

  io::Tokenizer tokenizer(input.get(), &file_error_collector);

  Parser parser;

  if (error_collector_ != NULL) {

    parser.RecordErrorsTo(&file_error_collector);

  }

  if (using_validation_error_collector_) {

    parser.RecordSourceLocationsTo(&source_locations_);

  }

  // Parse it.

  output->set_name(filename);

  return parser.Parse(&tokenizer, output) &&

         !file_error_collector.had_errors();

}

bool SourceTreeDescriptorDatabase::FindFileContainingSymbol(

    const string& symbol_name, FileDescriptorProto* output) {

  return false;

}

bool SourceTreeDescriptorDatabase::FindFileContainingExtension(

    const string& containing_type, int field_number,

    FileDescriptorProto* output) {

  return false;

}

// -------------------------------------------------------------------

SourceTreeDescriptorDatabase::ValidationErrorCollector::

ValidationErrorCollector(SourceTreeDescriptorDatabase* owner)

  : owner_(owner) {}

SourceTreeDescriptorDatabase::ValidationErrorCollector::

~ValidationErrorCollector() {}

void SourceTreeDescriptorDatabase::ValidationErrorCollector::AddError(

    const string& filename,

    const string& element_name,

    const Message* descriptor,

    ErrorLocation location,

    const string& message) {

  if (owner_->error_collector_ == NULL) return;

  int line, column;

  owner_->source_locations_.Find(descriptor, location, &line, &column);

  owner_->error_collector_->AddError(filename, line, column, message);

}

// ===================================================================

Importer::Importer(SourceTree* source_tree,

                   MultiFileErrorCollector* error_collector)

  : database_(source_tree),

    pool_(&database_, database_.GetValidationErrorCollector()) {

  database_.RecordErrorsTo(error_collector);

}

Importer::~Importer() {}

const FileDescriptor* Importer::Import(const string& filename) {

  return pool_.FindFileByName(filename);

}

// ===================================================================

SourceTree::~SourceTree() {}

DiskSourceTree::DiskSourceTree() {}

DiskSourceTree::~DiskSourceTree() {}

static inline char LastChar(const string& str) {

  return str[str.size() - 1];

}

// Given a path, returns an equivalent path with these changes:

// - On Windows, any backslashes are replaced with forward slashes.

// - Any instances of the directory "." are removed.

// - Any consecutive '/'s are collapsed into a single slash.

// Note that the resulting string may be empty.

//

// TODO(kenton):  It would be nice to handle "..", e.g. so that we can figure

//   out that "foo/bar.proto" is inside "baz/../foo".  However, if baz is a

//   symlink or doesn't exist, then things get complicated, and we can't

//   actually determine this without investigating the filesystem, probably

//   in non-portable ways.  So, we punt.

//

// TODO(kenton):  It would be nice to use realpath() here except that it

//   resolves symbolic links.  This could cause problems if people place

//   symbolic links in their source tree.  For example, if you executed:

//     protoc --proto_path=foo foo/bar/baz.proto

//   then if foo/bar is a symbolic link, foo/bar/baz.proto will canonicalize

//   to a path which does not appear to be under foo, and thus the compiler

//   will complain that baz.proto is not inside the --proto_path.

static string CanonicalizePath(string path) {

#ifdef _WIN32

  // The Win32 API accepts forward slashes as a path delimiter even though

  // backslashes are standard.  Let's avoid confusion and use only forward

  // slashes.

  if (HasPrefixString(path, "\\\\")) {

    // Avoid converting two leading backslashes.

    path = "\\\\" + StringReplace(path.substr(2), "\\", "/", true);

  } else {

    path = StringReplace(path, "\\", "/", true);

  }

#endif

  vector<string> parts;

  vector<string> canonical_parts;

  SplitStringUsing(path, "/", &parts);  // Note:  Removes empty parts.

  for (int i = 0; i < parts.size(); i++) {

    if (parts[i] == ".") {

      // Ignore.

    } else {

      canonical_parts.push_back(parts[i]);

    }

  }

  string result = JoinStrings(canonical_parts, "/");

  if (!path.empty() && path[0] == '/') {

    // Restore leading slash.

    result = '/' + result;

  }

  if (!path.empty() && LastChar(path) == '/' &&

      !result.empty() && LastChar(result) != '/') {

    // Restore trailing slash.

    result += '/';

  }

  return result;

}

static inline bool ContainsParentReference(const string& path) {

  return path == ".." ||

         HasPrefixString(path, "../") ||

         HasSuffixString(path, "/..") ||

         path.find("/../") != string::npos;

}

// Maps a file from an old location to a new one.  Typically, old_prefix is

// a virtual path and new_prefix is its corresponding disk path.  Returns

// false if the filename did not start with old_prefix, otherwise replaces

// old_prefix with new_prefix and stores the result in *result.  Examples:

//   string result;

//   assert(ApplyMapping("foo/bar", "", "baz", &result));

//   assert(result == "baz/foo/bar");

//

//   assert(ApplyMapping("foo/bar", "foo", "baz", &result));

//   assert(result == "baz/bar");

//

//   assert(ApplyMapping("foo", "foo", "bar", &result));

//   assert(result == "bar");

//

//   assert(!ApplyMapping("foo/bar", "baz", "qux", &result));

//   assert(!ApplyMapping("foo/bar", "baz", "qux", &result));

//   assert(!ApplyMapping("foobar", "foo", "baz", &result));

static bool ApplyMapping(const string& filename,

                         const string& old_prefix,

                         const string& new_prefix,

                         string* result) {

  if (old_prefix.empty()) {

    // old_prefix matches any relative path.

    if (ContainsParentReference(filename)) {

      // We do not allow the file name to use "..".

      return false;

    }

    if (HasPrefixString(filename, "/") ||

        IsWindowsAbsolutePath(filename)) {

      // This is an absolute path, so it isn't matched by the empty string.

      return false;

    }

    result->assign(new_prefix);

    if (!result->empty()) result->push_back('/');

    result->append(filename);

    return true;

  } else if (HasPrefixString(filename, old_prefix)) {

    // old_prefix is a prefix of the filename.  Is it the whole filename?

    if (filename.size() == old_prefix.size()) {

      // Yep, it's an exact match.

      *result = new_prefix;

      return true;

    } else {

      // Not an exact match.  Is the next character a '/'?  Otherwise,

      // this isn't actually a match at all.  E.g. the prefix "foo/bar"

      // does not match the filename "foo/barbaz".

      int after_prefix_start = -1;

      if (filename[old_prefix.size()] == '/') {

        after_prefix_start = old_prefix.size() + 1;

      } else if (filename[old_prefix.size() - 1] == '/') {

        // old_prefix is never empty, and canonicalized paths never have

        // consecutive '/' characters.

        after_prefix_start = old_prefix.size();

      }

      if (after_prefix_start != -1) {

        // Yep.  So the prefixes are directories and the filename is a file

        // inside them.

        string after_prefix = filename.substr(after_prefix_start);

        if (ContainsParentReference(after_prefix)) {

          // We do not allow the file name to use "..".

          return false;

        }

        result->assign(new_prefix);

        if (!result->empty()) result->push_back('/');

        result->append(after_prefix);

        return true;

      }

    }

  }

  return false;

}

void DiskSourceTree::MapPath(const string& virtual_path,

                             const string& disk_path) {

  mappings_.push_back(Mapping(virtual_path, CanonicalizePath(disk_path)));

}

DiskSourceTree::DiskFileToVirtualFileResult

DiskSourceTree::DiskFileToVirtualFile(

    const string& disk_file,

    string* virtual_file,

    string* shadowing_disk_file) {

  int mapping_index = -1;

  string canonical_disk_file = CanonicalizePath(disk_file);

  for (int i = 0; i < mappings_.size(); i++) {

    // Apply the mapping in reverse.

    if (ApplyMapping(canonical_disk_file, mappings_[i].disk_path,

                     mappings_[i].virtual_path, virtual_file)) {

      // Success.

      mapping_index = i;

      break;

    }

  }

  if (mapping_index == -1) {

    return NO_MAPPING;

  }

  // Iterate through all mappings with higher precedence and verify that none

  // of them map this file to some other existing file.

  for (int i = 0; i < mapping_index; i++) {

    if (ApplyMapping(*virtual_file, mappings_[i].virtual_path,

                     mappings_[i].disk_path, shadowing_disk_file)) {

      if (access(shadowing_disk_file->c_str(), F_OK) >= 0) {

        // File exists.

        return SHADOWED;

      }

    }

  }

  shadowing_disk_file->clear();

  // Verify that we can open the file.  Note that this also has the side-effect

  // of verifying that we are not canonicalizing away any non-existent

  // directories.

  scoped_ptr<io::ZeroCopyInputStream> stream(OpenDiskFile(disk_file));

  if (stream == NULL) {

    return CANNOT_OPEN;

  }

  return SUCCESS;

}

bool DiskSourceTree::VirtualFileToDiskFile(const string& virtual_file,

                                           string* disk_file) {

  scoped_ptr<io::ZeroCopyInputStream> stream(OpenVirtualFile(virtual_file,

                                                             disk_file));

  return stream != NULL;

}

io::ZeroCopyInputStream* DiskSourceTree::Open(const string& filename) {

  return OpenVirtualFile(filename, NULL);

}

io::ZeroCopyInputStream* DiskSourceTree::OpenVirtualFile(

    const string& virtual_file,

    string* disk_file) {

  if (virtual_file != CanonicalizePath(virtual_file) ||

      ContainsParentReference(virtual_file)) {

    // We do not allow importing of paths containing things like ".." or

    // consecutive slashes since the compiler expects files to be uniquely

    // identified by file name.

    return NULL;

  }

  for (int i = 0; i < mappings_.size(); i++) {

    string temp_disk_file;

    if (ApplyMapping(virtual_file, mappings_[i].virtual_path,

                     mappings_[i].disk_path, &temp_disk_file)) {

      io::ZeroCopyInputStream* stream = OpenDiskFile(temp_disk_file);

      if (stream != NULL) {

        if (disk_file != NULL) {

          *disk_file = temp_disk_file;

        }

        return stream;

      }

      if (errno == EACCES) {

        // The file exists but is not readable.

        // TODO(kenton):  Find a way to report this more nicely.

        GOOGLE_LOG(WARNING) << "Read access is denied for file: " << temp_disk_file;

        return NULL;

      }

    }

  }

  return NULL;

}

io::ZeroCopyInputStream* DiskSourceTree::OpenDiskFile(

    const string& filename) {

  int file_descriptor;

  do {

    file_descriptor = open(filename.c_str(), O_RDONLY);

  } while (file_descriptor < 0 && errno == EINTR);

  if (file_descriptor >= 0) {

    io::FileInputStream* result = new io::FileInputStream(file_descriptor);

    result->SetCloseOnDelete(true);

    return result;

  } else {

    return NULL;

  }

}

}  // namespace compiler

}  // namespace protobuf

}  // namespace google

// Protocol Buffers - Google's data interchange format

// Copyright 2008 Google Inc.  All rights reserved.

// http://code.google.com/p/protobuf/

//

// 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.

// Author: kenton@google.com (Kenton Varda)

//  Based on original Protocol Buffers design by

//  Sanjay Ghemawat, Jeff Dean, and others.

//

// This file is the public interface to the .proto file parser.

#ifndef GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__

#define GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__

#include <string>

#include <vector>

#include <set>

#include <utility>

#include <google/protobuf/descriptor.h>

#include <google/protobuf/descriptor_database.h>

#include <google/protobuf/compiler/parser.h>

namespace google {

namespace protobuf {

namespace io { class ZeroCopyInputStream; }

namespace compiler {

// Defined in this file.

class Importer;

class MultiFileErrorCollector;

class SourceTree;

class DiskSourceTree;

// TODO(kenton):  Move all SourceTree stuff to a separate file?

// An implementation of DescriptorDatabase which loads files from a SourceTree

// and parses them.

//

// Note:  This class is not thread-safe since it maintains a table of source

//   code locations for error reporting.  However, when a DescriptorPool wraps

//   a DescriptorDatabase, it uses mutex locking to make sure only one method

//   of the database is called at a time, even if the DescriptorPool is used

//   from multiple threads.  Therefore, there is only a problem if you create

//   multiple DescriptorPools wrapping the same SourceTreeDescriptorDatabase

//   and use them from multiple threads.

//

// Note:  This class does not implement FindFileContainingSymbol() or

//   FindFileContainingExtension(); these will always return false.

class LIBPROTOBUF_EXPORT SourceTreeDescriptorDatabase : public DescriptorDatabase {

 public:

  SourceTreeDescriptorDatabase(SourceTree* source_tree);

  ~SourceTreeDescriptorDatabase();

  // Instructs the SourceTreeDescriptorDatabase to report any parse errors

  // to the given MultiFileErrorCollector.  This should be called before

  // parsing.  error_collector must remain valid until either this method

  // is called again or the SourceTreeDescriptorDatabase is destroyed.

  void RecordErrorsTo(MultiFileErrorCollector* error_collector) {

    error_collector_ = error_collector;

  }

  // Gets a DescriptorPool::ErrorCollector which records errors to the

  // MultiFileErrorCollector specified with RecordErrorsTo().  This collector

  // has the ability to determine exact line and column numbers of errors

  // from the information given to it by the DescriptorPool.

  DescriptorPool::ErrorCollector* GetValidationErrorCollector() {

    using_validation_error_collector_ = true;

    return &validation_error_collector_;

  }

  // implements DescriptorDatabase -----------------------------------

  bool FindFileByName(const string& filename, FileDescriptorProto* output);

  bool FindFileContainingSymbol(const string& symbol_name,

                                FileDescriptorProto* output);

  bool FindFileContainingExtension(const string& containing_type,

                                   int field_number,

                                   FileDescriptorProto* output);

 private:

  class SingleFileErrorCollector;

  SourceTree* source_tree_;

  MultiFileErrorCollector* error_collector_;

  class LIBPROTOBUF_EXPORT ValidationErrorCollector : public DescriptorPool::ErrorCollector {

   public:

    ValidationErrorCollector(SourceTreeDescriptorDatabase* owner);

    ~ValidationErrorCollector();

    // implements ErrorCollector ---------------------------------------

    void AddError(const string& filename,

                  const string& element_name,

                  const Message* descriptor,

                  ErrorLocation location,

                  const string& message);

   private:

    SourceTreeDescriptorDatabase* owner_;

  };

  friend class ValidationErrorCollector;

  bool using_validation_error_collector_;

  SourceLocationTable source_locations_;

  ValidationErrorCollector validation_error_collector_;

};

// Simple interface for parsing .proto files.  This wraps the process

// of opening the file, parsing it with a Parser, recursively parsing all its

// imports, and then cross-linking the results to produce a FileDescriptor.

//

// This is really just a thin wrapper around SourceTreeDescriptorDatabase.

// You may find that SourceTreeDescriptorDatabase is more flexible.

//

// TODO(kenton):  I feel like this class is not well-named.

class LIBPROTOBUF_EXPORT Importer {

 public:

  Importer(SourceTree* source_tree,

           MultiFileErrorCollector* error_collector);

  ~Importer();

  // Import the given file and build a FileDescriptor representing it.  If

  // the file is already in the DescriptorPool, the existing FileDescriptor

  // will be returned.  The FileDescriptor is property of the DescriptorPool,

  // and will remain valid until it is destroyed.  If any errors occur, they

  // will be reported using the error collector and Import() will return NULL.

  //

  // A particular Importer object will only report errors for a particular

  // file once.  All future attempts to import the same file will return NULL

  // without reporting any errors.  The idea is that you might want to import

  // a lot of files without seeing the same errors over and over again.  If

  // you want to see errors for the same files repeatedly, you can use a

  // separate Importer object to import each one (but use the same

  // DescriptorPool so that they can be cross-linked).

  const FileDescriptor* Import(const string& filename);

  // The DescriptorPool in which all imported FileDescriptors and their

  // contents are stored.

  inline const DescriptorPool* pool() const {

    return &pool_;

  }

 private:

  SourceTreeDescriptorDatabase database_;

  DescriptorPool pool_;

  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Importer);

};

// If the importer encounters problems while trying to import the proto files,

// it reports them to a MultiFileErrorCollector.

class LIBPROTOBUF_EXPORT MultiFileErrorCollector {

 public:

  inline MultiFileErrorCollector() {}

  virtual ~MultiFileErrorCollector();

  // Line and column numbers are zero-based.  A line number of -1 indicates

  // an error with the entire file (e.g. "not found").

  virtual void AddError(const string& filename, int line, int column,

                        const string& message) = 0;

 private:

  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MultiFileErrorCollector);

};

// Abstract interface which represents a directory tree containing proto files.

// Used by the default implementation of Importer to resolve import statements

// Most users will probably want to use the DiskSourceTree implementation,

// below.

class LIBPROTOBUF_EXPORT SourceTree {

 public:

  inline SourceTree() {}

  virtual ~SourceTree();

  // Open the given file and return a stream that reads it, or NULL if not

  // found.  The caller takes ownership of the returned object.  The filename

  // must be a path relative to the root of the source tree and must not

  // contain "." or ".." components.

  virtual io::ZeroCopyInputStream* Open(const string& filename) = 0;

 private:

  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SourceTree);

};

// An implementation of SourceTree which loads files from locations on disk.

// Multiple mappings can be set up to map locations in the DiskSourceTree to

// locations in the physical filesystem.

class LIBPROTOBUF_EXPORT DiskSourceTree : public SourceTree {

 public:

  DiskSourceTree();

  ~DiskSourceTree();

  // Map a path on disk to a location in the SourceTree.  The path may be

  // either a file or a directory.  If it is a directory, the entire tree

  // under it will be mapped to the given virtual location.  To map a directory

  // to the root of the source tree, pass an empty string for virtual_path.

  //

  // If multiple mapped paths apply when opening a file, they will be searched

  // in order.  For example, if you do:

  //   MapPath("bar", "foo/bar");

  //   MapPath("", "baz");

  // and then you do:

  //   Open("bar/qux");

  // the DiskSourceTree will first try to open foo/bar/qux, then baz/bar/qux,

  // returning the first one that opens successfuly.

  //

  // disk_path may be an absolute path or relative to the current directory,

  // just like a path you'd pass to open().

  void MapPath(const string& virtual_path, const string& disk_path);

  // Return type for DiskFileToVirtualFile().

  enum DiskFileToVirtualFileResult {

    SUCCESS,

    SHADOWED,

    CANNOT_OPEN,

    NO_MAPPING

  };

  // Given a path to a file on disk, find a virtual path mapping to that

  // file.  The first mapping created with MapPath() whose disk_path contains

  // the filename is used.  However, that virtual path may not actually be

  // usable to open the given file.  Possible return values are:

  // * SUCCESS: The mapping was found.  *virtual_file is filled in so that

  //   calling Open(*virtual_file) will open the file named by disk_file.

  // * SHADOWED: A mapping was found, but using Open() to open this virtual

  //   path will end up returning some different file.  This is because some

  //   other mapping with a higher precedence also matches this virtual path

  //   and maps it to a different file that exists on disk.  *virtual_file

  //   is filled in as it would be in the SUCCESS case.  *shadowing_disk_file

  //   is filled in with the disk path of the file which would be opened if

  //   you were to call Open(*virtual_file).

  // * CANNOT_OPEN: The mapping was found and was not shadowed, but the

  //   file specified cannot be opened.  When this value is returned,

  //   errno will indicate the reason the file cannot be opened.  *virtual_file

  //   will be set to the virtual path as in the SUCCESS case, even though

  //   it is not useful.

  // * NO_MAPPING: Indicates that no mapping was found which contains this

  //   file.

  DiskFileToVirtualFileResult

    DiskFileToVirtualFile(const string& disk_file,

                          string* virtual_file,

                          string* shadowing_disk_file);

  // Given a virtual path, find the path to the file on disk.

  // Return true and update disk_file with the on-disk path if the file exists.

  // Return false and leave disk_file untouched if the file doesn't exist.

  bool VirtualFileToDiskFile(const string& virtual_file, string* disk_file);

  // implements SourceTree -------------------------------------------

  io::ZeroCopyInputStream* Open(const string& filename);

 private:

  struct Mapping {

    string virtual_path;

    string disk_path;

    inline Mapping(const string& virtual_path, const string& disk_path)

      : virtual_path(virtual_path), disk_path(disk_path) {}

  };

  vector<Mapping> mappings_;

  // Like Open(), but returns the on-disk path in disk_file if disk_file is

  // non-NULL and the file could be successfully opened.

  io::ZeroCopyInputStream* OpenVirtualFile(const string& virtual_file,

                                           string* disk_file);

  // Like Open() but given the actual on-disk path.

  io::ZeroCopyInputStream* OpenDiskFile(const string& filename);

  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DiskSourceTree);

};

}  // namespace compiler

}  // namespace protobuf

}  // namespace google

#endif  // GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__

// Protocol Buffers - Google's data interchange format

// Copyright 2008 Google Inc.  All rights reserved.

// http://code.google.com/p/protobuf/

//

// 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.

// Author: kenton@google.com (Kenton Varda)

//  Based on original Protocol Buffers design by

//  Sanjay Ghemawat, Jeff Dean, and others.

//

// Recursive descent FTW.

#include <float.h>

#include <google/protobuf/stubs/hash.h>

#include <limits>

#include <google/protobuf/compiler/parser.h>