text: // 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.
  //     * 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)
  #define HAVE_PTHREAD
  #include <google/protobuf/message_lite.h>  // TODO(gerbens) ideally remove this.
  #include <google/protobuf/stubs/common.h>
  #include <google/protobuf/stubs/once.h>
  #include <google/protobuf/stubs/status.h>
  #include <google/protobuf/stubs/stringpiece.h>
  #include <google/protobuf/stubs/strutil.h>
  #include <google/protobuf/stubs/int128.h>
  #include <errno.h>
  #include <sstream>
  #include <stdio.h>
  #include <vector>
  
  #ifdef _WIN32
  #define WIN32_LEAN_AND_MEAN  // We only need minimal includes
  #include <windows.h>
  #define snprintf _snprintf    // see comment in strutil.cc
  #elif defined(HAVE_PTHREAD)
  #include <pthread.h>
  #else
  #error "No suitable threading library available."
  #endif
  #if defined(__ANDROID__)
  #include <android/log.h>
  #endif
  
  namespace google {
  namespace protobuf {
  
  namespace internal {
  
  void VerifyVersion(int headerVersion,
                     int minLibraryVersion,
                     const char* filename) {
    if (GOOGLE_PROTOBUF_VERSION < minLibraryVersion) {
      // Library is too old for headers.
      GOOGLE_LOG(FATAL)
        << "This program requires version " << VersionString(minLibraryVersion)
        << " of the Protocol Buffer runtime library, but the installed version "
           "is " << VersionString(GOOGLE_PROTOBUF_VERSION) << ".  Please update "
           "your library.  If you compiled the program yourself, make sure that "
           "your headers are from the same version of Protocol Buffers as your "
           "link-time library.  (Version verification failed in \""
        << filename << "\".)";
    }
    if (headerVersion < kMinHeaderVersionForLibrary) {
      // Headers are too old for library.
      GOOGLE_LOG(FATAL)
        << "This program was compiled against version "
        << VersionString(headerVersion) << " of the Protocol Buffer runtime "
           "library, which is not compatible with the installed version ("
        << VersionString(GOOGLE_PROTOBUF_VERSION) <<  ").  Contact the program "
           "author for an update.  If you compiled the program yourself, make "
           "sure that your headers are from the same version of Protocol Buffers "
           "as your link-time library.  (Version verification failed in \""
        << filename << "\".)";
    }
  }
  
  string VersionString(int version) {
    int major = version / 1000000;
    int minor = (version / 1000) % 1000;
    int micro = version % 1000;
  
    // 128 bytes should always be enough, but we use snprintf() anyway to be
    // safe.
    char buffer[128];
    snprintf(buffer, sizeof(buffer), "%d.%d.%d", major, minor, micro);
  
    // Guard against broken MSVC snprintf().
    buffer[sizeof(buffer)-1] = '\0';
  
    return buffer;
  }
  
  }  // namespace internal
  
  // ===================================================================
  // emulates google3/base/logging.cc
  
  // If the minimum logging level is not set, we default to logging messages for
  // all levels.
  #ifndef GOOGLE_PROTOBUF_MIN_LOG_LEVEL
  #define GOOGLE_PROTOBUF_MIN_LOG_LEVEL LOGLEVEL_INFO
  #endif
  
  namespace internal {
  
  #if defined(__ANDROID__)
  inline void DefaultLogHandler(LogLevel level, const char* filename, int line,
                                const string& message) {
    if (level < GOOGLE_PROTOBUF_MIN_LOG_LEVEL) {
      return;
    }
    static const char* level_names[] = {"INFO", "WARNING", "ERROR", "FATAL"};
  
    static const int android_log_levels[] = {
        ANDROID_LOG_INFO,   // LOG(INFO),
        ANDROID_LOG_WARN,   // LOG(WARNING)
        ANDROID_LOG_ERROR,  // LOG(ERROR)
        ANDROID_LOG_FATAL,  // LOG(FATAL)
    };
  
    // Bound the logging level.
    const int android_log_level = android_log_levels[level];
    ::std::ostringstream ostr;
    ostr << "[libprotobuf " << level_names[level] << " " << filename << ":"
         << line << "] " << message.c_str();
  
    // Output the log string the Android log at the appropriate level.
    __android_log_write(android_log_level, "libprotobuf-native",
                        ostr.str().c_str());
    // Also output to std::cerr.
    fprintf(stderr, "%s", ostr.str().c_str());
    fflush(stderr);
  
    // Indicate termination if needed.
    if (android_log_level == ANDROID_LOG_FATAL) {
      __android_log_write(ANDROID_LOG_FATAL, "libprotobuf-native",
                          "terminating.\n");
    }
  }
  
  #else
  void DefaultLogHandler(LogLevel level, const char* filename, int line,
                         const string& message) {
    if (level < GOOGLE_PROTOBUF_MIN_LOG_LEVEL) {
      return;
    }
    static const char* level_names[] = { "INFO", "WARNING", "ERROR", "FATAL" };
  
    // We use fprintf() instead of cerr because we want this to work at static
    // initialization time.
    fprintf(stderr, "[libprotobuf %s %s:%d] %s\n",
            level_names[level], filename, line, message.c_str());
    fflush(stderr);  // Needed on MSVC.
  }
  #endif
  
  void NullLogHandler(LogLevel /* level */, const char* /* filename */,
                      int /* line */, const string& /* message */) {
    // Nothing.
  }
  
  static LogHandler* log_handler_ = &DefaultLogHandler;
  static int log_silencer_count_ = 0;
  
  static Mutex* log_silencer_count_mutex_ = NULL;
  GOOGLE_PROTOBUF_DECLARE_ONCE(log_silencer_count_init_);
  
  void DeleteLogSilencerCount() {
    delete log_silencer_count_mutex_;
    log_silencer_count_mutex_ = NULL;
  }
  void InitLogSilencerCount() {
    log_silencer_count_mutex_ = new Mutex;
    OnShutdown(&DeleteLogSilencerCount);
  }
  void InitLogSilencerCountOnce() {
    GoogleOnceInit(&log_silencer_count_init_, &InitLogSilencerCount);
  }
  
  LogMessage& LogMessage::operator<<(const string& value) {
    message_ += value;
    return *this;
  }
  
  LogMessage& LogMessage::operator<<(const char* value) {
    message_ += value;
    return *this;
  }
  
  LogMessage& LogMessage::operator<<(const StringPiece& value) {
    message_ += value.ToString();
    return *this;
  }
  
  
  // Since this is just for logging, we don't care if the current locale changes
  // the results -- in fact, we probably prefer that.  So we use snprintf()
  // instead of Simple*toa().
  #undef DECLARE_STREAM_OPERATOR
  #define DECLARE_STREAM_OPERATOR(TYPE, FORMAT)                       \
    LogMessage& LogMessage::operator<<(TYPE value) {                  \
      /* 128 bytes should be big enough for any of the primitive */   \
      /* values which we print with this, but well use snprintf() */  \
      /* anyway to be extra safe. */                                  \
      char buffer[128];                                               \
      snprintf(buffer, sizeof(buffer), FORMAT, value);                \
      /* Guard against broken MSVC snprintf(). */                     \
      buffer[sizeof(buffer)-1] = '\0';                                \
      message_ += buffer;                                             \
      return *this;                                                   \
    }
  
  DECLARE_STREAM_OPERATOR(char         , "%c" )
  DECLARE_STREAM_OPERATOR(int          , "%d" )
  DECLARE_STREAM_OPERATOR(unsigned int , "%u" )
  DECLARE_STREAM_OPERATOR(long         , "%ld")
  DECLARE_STREAM_OPERATOR(unsigned long, "%lu")
  DECLARE_STREAM_OPERATOR(double       , "%g" )
  DECLARE_STREAM_OPERATOR(void*        , "%p" )
  DECLARE_STREAM_OPERATOR(long long         , "%" GOOGLE_LL_FORMAT "d")
  DECLARE_STREAM_OPERATOR(unsigned long long, "%" GOOGLE_LL_FORMAT "u")
  #undef DECLARE_STREAM_OPERATOR
  
  LogMessage::LogMessage(LogLevel level, const char* filename, int line)
    : level_(level), filename_(filename), line_(line) {}
  LogMessage::~LogMessage() {}
  
  void LogMessage::Finish() {
    bool suppress = false;
  
    if (level_ != LOGLEVEL_FATAL) {
      InitLogSilencerCountOnce();
      MutexLock lock(log_silencer_count_mutex_);
      suppress = log_silencer_count_ > 0;
    }
  
    if (!suppress) {
      log_handler_(level_, filename_, line_, message_);
    }
  
    if (level_ == LOGLEVEL_FATAL) {
  #if PROTOBUF_USE_EXCEPTIONS
      throw FatalException(filename_, line_, message_);
  #else
      abort();
  #endif
    }
  }
  
  void LogFinisher::operator=(LogMessage& other) {
    other.Finish();
  }
  
  }  // namespace internal
  
  LogHandler* SetLogHandler(LogHandler* new_func) {
    LogHandler* old = internal::log_handler_;
    if (old == &internal::NullLogHandler) {
      old = NULL;
    }
    if (new_func == NULL) {
      internal::log_handler_ = &internal::NullLogHandler;
    } else {
      internal::log_handler_ = new_func;
    }
    return old;
  }
  
  LogSilencer::LogSilencer() {
    internal::InitLogSilencerCountOnce();
    MutexLock lock(internal::log_silencer_count_mutex_);
    ++internal::log_silencer_count_;
  };
  
  LogSilencer::~LogSilencer() {
    internal::InitLogSilencerCountOnce();
    MutexLock lock(internal::log_silencer_count_mutex_);
    --internal::log_silencer_count_;
  };
  
  // ===================================================================
  // emulates google3/base/callback.cc
  
  Closure::~Closure() {}
  
  namespace internal { FunctionClosure0::~FunctionClosure0() {} }
  
  void DoNothing() {}
  
  // ===================================================================
  // emulates google3/base/mutex.cc
  
  #ifdef _WIN32
  
  struct Mutex::Internal {
    CRITICAL_SECTION mutex;
  #ifndef NDEBUG
    // Used only to implement AssertHeld().
    DWORD thread_id;
  #endif
  };
  
  Mutex::Mutex()
    : mInternal(new Internal) {
    InitializeCriticalSection(&mInternal->mutex);
  }
  
  Mutex::~Mutex() {
    DeleteCriticalSection(&mInternal->mutex);
    delete mInternal;
  }
  
  void Mutex::Lock() {
    EnterCriticalSection(&mInternal->mutex);
  #ifndef NDEBUG
    mInternal->thread_id = GetCurrentThreadId();
  #endif
  }
  
  void Mutex::Unlock() {
  #ifndef NDEBUG
    mInternal->thread_id = 0;
  #endif
    LeaveCriticalSection(&mInternal->mutex);
  }
  
  void Mutex::AssertHeld() {
  #ifndef NDEBUG
    GOOGLE_DCHECK_EQ(mInternal->thread_id, GetCurrentThreadId());
  #endif
  }
  
  #elif defined(HAVE_PTHREAD)
  
  struct Mutex::Internal {
    pthread_mutex_t mutex;
  };
  
  Mutex::Mutex()
    : mInternal(new Internal) {
    pthread_mutex_init(&mInternal->mutex, NULL);
  }
  
  Mutex::~Mutex() {
    pthread_mutex_destroy(&mInternal->mutex);
    delete mInternal;
  }
  
  void Mutex::Lock() {
    int result = pthread_mutex_lock(&mInternal->mutex);
    if (result != 0) {
      GOOGLE_LOG(FATAL) << "pthread_mutex_lock: " << strerror(result);
    }
  }
  
  void Mutex::Unlock() {
    int result = pthread_mutex_unlock(&mInternal->mutex);
    if (result != 0) {
      GOOGLE_LOG(FATAL) << "pthread_mutex_unlock: " << strerror(result);
    }
  }
  
  void Mutex::AssertHeld() {
    // pthreads dosn't provide a way to check which thread holds the mutex.
    // TODO(kenton):  Maybe keep track of locking thread ID like with WIN32?
  }
  
  #endif
  
  // ===================================================================
  // emulates google3/util/endian/endian.h
  //
  // TODO(xiaofeng): PROTOBUF_LITTLE_ENDIAN is unfortunately defined in
  // google/protobuf/io/coded_stream.h and therefore can not be used here.
  // Maybe move that macro definition here in the furture.
  uint32 ghtonl(uint32 x) {
    union {
      uint32 result;
      uint8 result_array[4];
    };
    result_array[0] = static_cast<uint8>(x >> 24);
    result_array[1] = static_cast<uint8>((x >> 16) & 0xFF);
    result_array[2] = static_cast<uint8>((x >> 8) & 0xFF);
    result_array[3] = static_cast<uint8>(x & 0xFF);
    return result;
  }
  
  // ===================================================================
  // Shutdown support.
  
  namespace internal {
  
  typedef void OnShutdownFunc();
  struct ShutdownData {
    ~ShutdownData() {
      for (int i = 0; i < functions.size(); i++) {
        functions[i]();
      }
      for (int i = 0; i < strings.size(); i++) {
        strings[i]->~string();
      }
      for (int i = 0; i < messages.size(); i++) {
        messages[i]->~MessageLite();
      }
    }
  
    vector<void (*)()> functions;
    vector<const std::string*> strings;
    vector<const MessageLite*> messages;
    Mutex mutex;
  };
  
  ShutdownData* shutdown_data = NULL;
  GOOGLE_PROTOBUF_DECLARE_ONCE(shutdown_functions_init);
  
  void InitShutdownFunctions() {
    shutdown_data = new ShutdownData;
  }
  
  inline void InitShutdownFunctionsOnce() {
    GoogleOnceInit(&shutdown_functions_init, &InitShutdownFunctions);
  }
  
  void OnShutdown(void (*func)()) {
    InitShutdownFunctionsOnce();
    MutexLock lock(&shutdown_data->mutex);
    shutdown_data->functions.push_back(func);
  }
  
  void OnShutdownDestroyString(const std::string* ptr) {
    InitShutdownFunctionsOnce();
    MutexLock lock(&shutdown_data->mutex);
    shutdown_data->strings.push_back(ptr);
  }
  
  void OnShutdownDestroyMessage(const void* ptr) {
    InitShutdownFunctionsOnce();
    MutexLock lock(&shutdown_data->mutex);
    shutdown_data->messages.push_back(static_cast<const MessageLite*>(ptr));
  }
  
  }  // namespace internal
  
  void ShutdownProtobufLibrary() {
    internal::InitShutdownFunctionsOnce();
  
    // We don't need to lock shutdown_functions_mutex because it's up to the
    // caller to make sure that no one is using the library before this is
    // called.
  
    // Make it safe to call this multiple times.
    if (internal::shutdown_data == NULL) return;
  
    delete internal::shutdown_data;
    internal::shutdown_data = NULL;
  }
  
  #if PROTOBUF_USE_EXCEPTIONS
  FatalException::~FatalException() throw() {}
  
  const char* FatalException::what() const throw() {
    return message_.c_str();
  }
  #endif
  
  }  // namespace protobuf
  }  // namespace google
  