// base/kaldi-error.h

// Copyright 2019 LAIX (Yi Sun)
// Copyright 2019 SmartAction LLC (kkm)
// Copyright 2016 Brno University of Technology (author: Karel Vesely)
// Copyright 2009-2011  Microsoft Corporation;  Ondrej Glembek;  Lukas Burget;
//                      Saarland University

// See ../../COPYING for clarification regarding multiple authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.

#ifndef KALDI_BASE_KALDI_ERROR_H_
#define KALDI_BASE_KALDI_ERROR_H_ 1

#include <cstdio>
#include <cstring>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>

#include "base/kaldi-types.h"
#include "base/kaldi-utils.h"
/* Important that this file does not depend on any other kaldi headers. */

#ifdef _MSC_VER
#define __func__ __FUNCTION__
#endif

namespace kaldi {

/// \addtogroup error_group
/// @{

/***** PROGRAM NAME AND VERBOSITY LEVEL *****/

/// Called by ParseOptions to set base name (no directory) of the executing
/// program. The name is printed in logging code along with every message,
/// because in our scripts, we often mix together the stderr of many programs.
/// This function is very thread-unsafe.
void SetProgramName(const char *basename);

/// This is set by util/parse-options.{h,cc} if you set --verbose=? option.
/// Do not use directly, prefer {Get,Set}VerboseLevel().
extern int32 g_kaldi_verbose_level;

/// Get verbosity level, usually set via command line '--verbose=' switch.
inline int32 GetVerboseLevel() { return g_kaldi_verbose_level; }

/// This should be rarely used, except by programs using Kaldi as library;
/// command-line programs set the verbose level automatically from ParseOptions.
inline void SetVerboseLevel(int32 i) { g_kaldi_verbose_level = i; }

/***** KALDI LOGGING *****/

/// Log message severity and source location info.
struct LogMessageEnvelope {
  /// Message severity. In addition to these levels, positive values (1 to 6)
  /// specify verbose logging level. Verbose messages are produced only when
  /// SetVerboseLevel() has been called to set logging level to at least the
  /// corresponding value.
  enum Severity {
    kAssertFailed = -3, //!< Assertion failure. abort() will be called.
    kError = -2,        //!< Fatal error. KaldiFatalError will be thrown.
    kWarning = -1,      //!< Indicates a recoverable but abnormal condition.
    kInfo = 0,          //!< Informational message.
  };
  int severity;     //!< A Severity value, or positive verbosity level.
  const char *func; //!< Name of the function invoking the logging.
  const char *file; //!< Source file name with up to 1 leading directory.
  int32 line;       //<! Line number in the source file.
};

/// Kaldi fatal runtime error exception. This exception is thrown from any use
/// of the KALDI_ERR logging macro after the logging function, either set by
/// SetLogHandler(), or the Kaldi's internal one, has returned.
class KaldiFatalError : public std::runtime_error {
public:
  explicit KaldiFatalError(const std::string &message)
      : std::runtime_error(message) {}
  explicit KaldiFatalError(const char *message) : std::runtime_error(message) {}

  /// Returns the exception name, "kaldi::KaldiFatalError".
  virtual const char *what() const noexcept override {
    return "kaldi::KaldiFatalError";
  }

  /// Returns the Kaldi error message logged by KALDI_ERR.
  const char *KaldiMessage() const { return std::runtime_error::what(); }
};

// Class MessageLogger is the workhorse behind the KALDI_ASSERT, KALDI_ERR,
// KALDI_WARN, KALDI_LOG and KALDI_VLOG macros. It formats the message, then
// either prints it to stderr or passes to the custom logging handler if
// provided. Then, in case of the error, throws a KaldiFatalError exception, or
// in case of failed KALDI_ASSERT, calls std::abort().
class MessageLogger {
public:
  /// The constructor stores the message's "envelope", a set of data which
  // identifies the location in source which is sending the message to log.
  // The pointers to strings are stored internally, and not owned or copied,
  // so that their storage must outlive this object.
  MessageLogger(LogMessageEnvelope::Severity severity, const char *func,
                const char *file, int32 line);

  // The stream insertion operator, used in e.g. 'KALDI_LOG << "Message"'.
  template <typename T> MessageLogger &operator<<(const T &val) {
    ss_ << val;
    return *this;
  }

  // When assigned a MessageLogger, log its contents.
  struct Log final {
    void operator=(const MessageLogger &logger) { logger.LogMessage(); }
  };

  // When assigned a MessageLogger, log its contents and then throw
  // a KaldiFatalError.
  struct LogAndThrow final {
    [[noreturn]] void operator=(const MessageLogger &logger) {
      logger.LogMessage();
      throw KaldiFatalError(logger.GetMessage());
    }
  };

private:
  std::string GetMessage() const { return ss_.str(); }
  void LogMessage() const;

  LogMessageEnvelope envelope_;
  std::ostringstream ss_;
};

// Logging macros.
#define KALDI_ERR                                                              \
  ::kaldi::MessageLogger::LogAndThrow() = ::kaldi::MessageLogger(              \
      ::kaldi::LogMessageEnvelope::kError, __func__, __FILE__, __LINE__)
#define KALDI_WARN                                                             \
  ::kaldi::MessageLogger::Log() = ::kaldi::MessageLogger(                      \
      ::kaldi::LogMessageEnvelope::kWarning, __func__, __FILE__, __LINE__)
#define KALDI_LOG                                                              \
  ::kaldi::MessageLogger::Log() = ::kaldi::MessageLogger(                      \
      ::kaldi::LogMessageEnvelope::kInfo, __func__, __FILE__, __LINE__)
#define KALDI_VLOG(v)                                                          \
  if ((v) <= ::kaldi::GetVerboseLevel())                                       \
  ::kaldi::MessageLogger::Log() =                                              \
      ::kaldi::MessageLogger((::kaldi::LogMessageEnvelope::Severity)(v),       \
                             __func__, __FILE__, __LINE__)

/***** KALDI ASSERTS *****/

[[noreturn]] void KaldiAssertFailure_(const char *func, const char *file,
                                      int32 line, const char *cond_str);

// Note on KALDI_ASSERT and KALDI_PARANOID_ASSERT:
//
// A single block {} around if /else  does not work, because it causes
// syntax error (unmatched else block) in the following code:
//
// if (condition)
//   KALDI_ASSERT(condition2);
// else
//   SomethingElse();
//
// do {} while(0) -- note there is no semicolon at the end! -- works nicely,
// and compilers will be able to optimize the loop away (as the condition
// is always false).
//
// Also see KALDI_COMPILE_TIME_ASSERT, defined in base/kaldi-utils.h, and
// KALDI_ASSERT_IS_INTEGER_TYPE and KALDI_ASSERT_IS_FLOATING_TYPE, also defined
// there.
#ifndef NDEBUG
#define KALDI_ASSERT(cond)                                                     \
  do {                                                                         \
    if (cond)                                                                  \
      (void)0;                                                                 \
    else                                                                       \
      ::kaldi::KaldiAssertFailure_(__func__, __FILE__, __LINE__, #cond);       \
  } while (0)
#else
#define KALDI_ASSERT(cond) (void)0
#endif

// Some more expensive asserts only checked if this defined.
#ifdef KALDI_PARANOID
#define KALDI_PARANOID_ASSERT(cond)                                            \
  do {                                                                         \
    if (cond)                                                                  \
      (void)0;                                                                 \
    else                                                                       \
      ::kaldi::KaldiAssertFailure_(__func__, __FILE__, __LINE__, #cond);       \
  } while (0)
#else
#define KALDI_PARANOID_ASSERT(cond) (void)0
#endif

/***** THIRD-PARTY LOG-HANDLER *****/

/// Type of third-party logging function.
typedef void (*LogHandler)(const LogMessageEnvelope &envelope,
                           const char *message);

/// Set logging handler. If called with a non-NULL function pointer, the
/// function pointed by it is called to send messages to a caller-provided log.
/// If called with a NULL pointer, restores default Kaldi error logging to
/// stderr. This function is obviously not thread safe; the log handler must be.
/// Returns a previously set logging handler pointer, or NULL.
LogHandler SetLogHandler(LogHandler);

/// @} end "addtogroup error_group"

// Functions within internal is exported for testing only, do not use.
namespace internal {
bool LocateSymbolRange(const std::string &trace_name, size_t *begin,
                       size_t *end);
} // namespace internal
} // namespace kaldi

#endif // KALDI_BASE_KALDI_ERROR_H_