kaldi-error.h

Go to the documentation of this file.

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


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

void SetProgramName(const char *basename);

extern int32 g_kaldi_verbose_level;

inline int32 GetVerboseLevel() { return g_kaldi_verbose_level; }

inline void SetVerboseLevel(int32 i) { g_kaldi_verbose_level = i; }

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

struct LogMessageEnvelope {
  enum Severity {
    kAssertFailed = -3, 
    kError = -2,        
    kWarning = -1,      
    kInfo = 0,          
  };
  int severity;     
  const char *func; 
  const char *file; 
  int32 line;       //<! Line number in the source file.
};

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) {}

  virtual const char *what() const noexcept override {
    return "kaldi::KaldiFatalError";
  }

  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:
  // 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 *****/

typedef void (*LogHandler)(const LogMessageEnvelope &envelope,
                           const char *message);

LogHandler SetLogHandler(LogHandler);


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