cannam@62: // Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
cannam@62: // Licensed under the MIT License:
cannam@62: //
cannam@62: // Permission is hereby granted, free of charge, to any person obtaining a copy
cannam@62: // of this software and associated documentation files (the "Software"), to deal
cannam@62: // in the Software without restriction, including without limitation the rights
cannam@62: // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
cannam@62: // copies of the Software, and to permit persons to whom the Software is
cannam@62: // furnished to do so, subject to the following conditions:
cannam@62: //
cannam@62: // The above copyright notice and this permission notice shall be included in
cannam@62: // all copies or substantial portions of the Software.
cannam@62: //
cannam@62: // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
cannam@62: // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
cannam@62: // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
cannam@62: // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
cannam@62: // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
cannam@62: // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
cannam@62: // THE SOFTWARE.
cannam@62: 
cannam@62: // This file declares convenient macros for debug logging and error handling.  The macros make
cannam@62: // it excessively easy to extract useful context information from code.  Example:
cannam@62: //
cannam@62: //     KJ_ASSERT(a == b, a, b, "a and b must be the same.");
cannam@62: //
cannam@62: // On failure, this will throw an exception whose description looks like:
cannam@62: //
cannam@62: //     myfile.c++:43: bug in code: expected a == b; a = 14; b = 72; a and b must be the same.
cannam@62: //
cannam@62: // As you can see, all arguments after the first provide additional context.
cannam@62: //
cannam@62: // The macros available are:
cannam@62: //
cannam@62: // * `KJ_LOG(severity, ...)`:  Just writes a log message, to stderr by default (but you can
cannam@62: //   intercept messages by implementing an ExceptionCallback).  `severity` is `INFO`, `WARNING`,
cannam@62: //   `ERROR`, or `FATAL`.  By default, `INFO` logs are not written, but for command-line apps the
cannam@62: //   user should be able to pass a flag like `--verbose` to enable them.  Other log levels are
cannam@62: //   enabled by default.  Log messages -- like exceptions -- can be intercepted by registering an
cannam@62: //   ExceptionCallback.
cannam@62: //
cannam@62: // * `KJ_DBG(...)`:  Like `KJ_LOG`, but intended specifically for temporary log lines added while
cannam@62: //   debugging a particular problem.  Calls to `KJ_DBG` should always be deleted before committing
cannam@62: //   code.  It is suggested that you set up a pre-commit hook that checks for this.
cannam@62: //
cannam@62: // * `KJ_ASSERT(condition, ...)`:  Throws an exception if `condition` is false, or aborts if
cannam@62: //   exceptions are disabled.  This macro should be used to check for bugs in the surrounding code
cannam@62: //   and its dependencies, but NOT to check for invalid input.  The macro may be followed by a
cannam@62: //   brace-delimited code block; if so, the block will be executed in the case where the assertion
cannam@62: //   fails, before throwing the exception.  If control jumps out of the block (e.g. with "break",
cannam@62: //   "return", or "goto"), then the error is considered "recoverable" -- in this case, if
cannam@62: //   exceptions are disabled, execution will continue normally rather than aborting (but if
cannam@62: //   exceptions are enabled, an exception will still be thrown on exiting the block). A "break"
cannam@62: //   statement in particular will jump to the code immediately after the block (it does not break
cannam@62: //   any surrounding loop or switch).  Example:
cannam@62: //
cannam@62: //       KJ_ASSERT(value >= 0, "Value cannot be negative.", value) {
cannam@62: //         // Assertion failed.  Set value to zero to "recover".
cannam@62: //         value = 0;
cannam@62: //         // Don't abort if exceptions are disabled.  Continue normally.
cannam@62: //         // (Still throw an exception if they are enabled, though.)
cannam@62: //         break;
cannam@62: //       }
cannam@62: //       // When exceptions are disabled, we'll get here even if the assertion fails.
cannam@62: //       // Otherwise, we get here only if the assertion passes.
cannam@62: //
cannam@62: // * `KJ_REQUIRE(condition, ...)`:  Like `KJ_ASSERT` but used to check preconditions -- e.g. to
cannam@62: //   validate parameters passed from a caller.  A failure indicates that the caller is buggy.
cannam@62: //
cannam@62: // * `KJ_SYSCALL(code, ...)`:  Executes `code` assuming it makes a system call.  A negative result
cannam@62: //   is considered an error, with error code reported via `errno`.  EINTR is handled by retrying.
cannam@62: //   Other errors are handled by throwing an exception.  If you need to examine the return code,
cannam@62: //   assign it to a variable like so:
cannam@62: //
cannam@62: //       int fd;
cannam@62: //       KJ_SYSCALL(fd = open(filename, O_RDONLY), filename);
cannam@62: //
cannam@62: //   `KJ_SYSCALL` can be followed by a recovery block, just like `KJ_ASSERT`.
cannam@62: //
cannam@62: // * `KJ_NONBLOCKING_SYSCALL(code, ...)`:  Like KJ_SYSCALL, but will not throw an exception on
cannam@62: //   EAGAIN/EWOULDBLOCK.  The calling code should check the syscall's return value to see if it
cannam@62: //   indicates an error; in this case, it can assume the error was EAGAIN because any other error
cannam@62: //   would have caused an exception to be thrown.
cannam@62: //
cannam@62: // * `KJ_CONTEXT(...)`:  Notes additional contextual information relevant to any exceptions thrown
cannam@62: //   from within the current scope.  That is, until control exits the block in which KJ_CONTEXT()
cannam@62: //   is used, if any exception is generated, it will contain the given information in its context
cannam@62: //   chain.  This is helpful because it can otherwise be very difficult to come up with error
cannam@62: //   messages that make sense within low-level helper code.  Note that the parameters to
cannam@62: //   KJ_CONTEXT() are only evaluated if an exception is thrown.  This implies that any variables
cannam@62: //   used must remain valid until the end of the scope.
cannam@62: //
cannam@62: // Notes:
cannam@62: // * Do not write expressions with side-effects in the message content part of the macro, as the
cannam@62: //   message will not necessarily be evaluated.
cannam@62: // * For every macro `FOO` above except `LOG`, there is also a `FAIL_FOO` macro used to report
cannam@62: //   failures that already happened.  For the macros that check a boolean condition, `FAIL_FOO`
cannam@62: //   omits the first parameter and behaves like it was `false`.  `FAIL_SYSCALL` and
cannam@62: //   `FAIL_RECOVERABLE_SYSCALL` take a string and an OS error number as the first two parameters.
cannam@62: //   The string should be the name of the failed system call.
cannam@62: // * For every macro `FOO` above, there is a `DFOO` version (or `RECOVERABLE_DFOO`) which is only
cannam@62: //   executed in debug mode, i.e. when KJ_DEBUG is defined.  KJ_DEBUG is defined automatically
cannam@62: //   by common.h when compiling without optimization (unless NDEBUG is defined), but you can also
cannam@62: //   define it explicitly (e.g. -DKJ_DEBUG).  Generally, production builds should NOT use KJ_DEBUG
cannam@62: //   as it may enable expensive checks that are unlikely to fail.
cannam@62: 
cannam@62: #ifndef KJ_DEBUG_H_
cannam@62: #define KJ_DEBUG_H_
cannam@62: 
cannam@62: #if defined(__GNUC__) && !KJ_HEADER_WARNINGS
cannam@62: #pragma GCC system_header
cannam@62: #endif
cannam@62: 
cannam@62: #include "string.h"
cannam@62: #include "exception.h"
cannam@62: 
cannam@62: #ifdef ERROR
cannam@62: // This is problematic because windows.h #defines ERROR, which we use in an enum here.
cannam@62: #error "Make sure to to undefine ERROR (or just #include <kj/windows-sanity.h>) before this file"
cannam@62: #endif
cannam@62: 
cannam@62: namespace kj {
cannam@62: 
cannam@62: #if _MSC_VER
cannam@62: // MSVC does __VA_ARGS__ differently from GCC:
cannam@62: // - A trailing comma before an empty __VA_ARGS__ is removed automatically, whereas GCC wants
cannam@62: //   you to request this behavior with "##__VA_ARGS__".
cannam@62: // - If __VA_ARGS__ is passed directly as an argument to another macro, it will be treated as a
cannam@62: //   *single* argument rather than an argument list. This can be worked around by wrapping the
cannam@62: //   outer macro call in KJ_EXPAND(), which appraently forces __VA_ARGS__ to be expanded before
cannam@62: //   the macro is evaluated. I don't understand the C preprocessor.
cannam@62: // - Using "#__VA_ARGS__" to stringify __VA_ARGS__ expands to zero tokens when __VA_ARGS__ is
cannam@62: //   empty, rather than expanding to an empty string literal. We can work around by concatenating
cannam@62: //   with an empty string literal.
cannam@62: 
cannam@62: #define KJ_EXPAND(X) X
cannam@62: 
cannam@62: #define KJ_LOG(severity, ...) \
cannam@62:   if (!::kj::_::Debug::shouldLog(::kj::LogSeverity::severity)) {} else \
cannam@62:     ::kj::_::Debug::log(__FILE__, __LINE__, ::kj::LogSeverity::severity, \
cannam@62:                         "" #__VA_ARGS__, __VA_ARGS__)
cannam@62: 
cannam@62: #define KJ_DBG(...) KJ_EXPAND(KJ_LOG(DBG, __VA_ARGS__))
cannam@62: 
cannam@62: #define KJ_REQUIRE(cond, ...) \
cannam@62:   if (KJ_LIKELY(cond)) {} else \
cannam@62:     for (::kj::_::Debug::Fault f(__FILE__, __LINE__, ::kj::Exception::Type::FAILED, \
cannam@62:                                  #cond, "" #__VA_ARGS__, __VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_FAIL_REQUIRE(...) \
cannam@62:   for (::kj::_::Debug::Fault f(__FILE__, __LINE__, ::kj::Exception::Type::FAILED, \
cannam@62:                                nullptr, "" #__VA_ARGS__, __VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_SYSCALL(call, ...) \
cannam@62:   if (auto _kjSyscallResult = ::kj::_::Debug::syscall([&](){return (call);}, false)) {} else \
cannam@62:     for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:              _kjSyscallResult.getErrorNumber(), #call, "" #__VA_ARGS__, __VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_NONBLOCKING_SYSCALL(call, ...) \
cannam@62:   if (auto _kjSyscallResult = ::kj::_::Debug::syscall([&](){return (call);}, true)) {} else \
cannam@62:     for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:              _kjSyscallResult.getErrorNumber(), #call, "" #__VA_ARGS__, __VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_FAIL_SYSCALL(code, errorNumber, ...) \
cannam@62:   for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:            errorNumber, code, "" #__VA_ARGS__, __VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #if _WIN32
cannam@62: 
cannam@62: #define KJ_WIN32(call, ...) \
cannam@62:   if (::kj::_::Debug::isWin32Success(call)) {} else \
cannam@62:     for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:              ::kj::_::Debug::getWin32Error(), #call, "" #__VA_ARGS__, __VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_WINSOCK(call, ...) \
cannam@62:   if ((call) != SOCKET_ERROR) {} else \
cannam@62:     for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:              ::kj::_::Debug::getWin32Error(), #call, "" #__VA_ARGS__, __VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_FAIL_WIN32(code, errorNumber, ...) \
cannam@62:   for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:            ::kj::_::Debug::Win32Error(errorNumber), code, "" #__VA_ARGS__, __VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #endif
cannam@62: 
cannam@62: #define KJ_UNIMPLEMENTED(...) \
cannam@62:   for (::kj::_::Debug::Fault f(__FILE__, __LINE__, ::kj::Exception::Type::UNIMPLEMENTED, \
cannam@62:                                nullptr, "" #__VA_ARGS__, __VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: // TODO(msvc):  MSVC mis-deduces `ContextImpl<decltype(func)>` as `ContextImpl<int>` in some edge
cannam@62: // cases, such as inside nested lambdas inside member functions. Wrapping the type in
cannam@62: // `decltype(instance<...>())` helps it deduce the context function's type correctly.
cannam@62: #define KJ_CONTEXT(...) \
cannam@62:   auto KJ_UNIQUE_NAME(_kjContextFunc) = [&]() -> ::kj::_::Debug::Context::Value { \
cannam@62:         return ::kj::_::Debug::Context::Value(__FILE__, __LINE__, \
cannam@62:             ::kj::_::Debug::makeDescription("" #__VA_ARGS__, __VA_ARGS__)); \
cannam@62:       }; \
cannam@62:   decltype(::kj::instance<::kj::_::Debug::ContextImpl<decltype(KJ_UNIQUE_NAME(_kjContextFunc))>>()) \
cannam@62:       KJ_UNIQUE_NAME(_kjContext)(KJ_UNIQUE_NAME(_kjContextFunc))
cannam@62: 
cannam@62: #define KJ_REQUIRE_NONNULL(value, ...) \
cannam@62:   (*[&] { \
cannam@62:     auto _kj_result = ::kj::_::readMaybe(value); \
cannam@62:     if (KJ_UNLIKELY(!_kj_result)) { \
cannam@62:       ::kj::_::Debug::Fault(__FILE__, __LINE__, ::kj::Exception::Type::FAILED, \
cannam@62:                             #value " != nullptr", "" #__VA_ARGS__, __VA_ARGS__).fatal(); \
cannam@62:     } \
cannam@62:     return _kj_result; \
cannam@62:   }())
cannam@62: 
cannam@62: #define KJ_EXCEPTION(type, ...) \
cannam@62:   ::kj::Exception(::kj::Exception::Type::type, __FILE__, __LINE__, \
cannam@62:       ::kj::_::Debug::makeDescription("" #__VA_ARGS__, __VA_ARGS__))
cannam@62: 
cannam@62: #else
cannam@62: 
cannam@62: #define KJ_LOG(severity, ...) \
cannam@62:   if (!::kj::_::Debug::shouldLog(::kj::LogSeverity::severity)) {} else \
cannam@62:     ::kj::_::Debug::log(__FILE__, __LINE__, ::kj::LogSeverity::severity, \
cannam@62:                         #__VA_ARGS__, ##__VA_ARGS__)
cannam@62: 
cannam@62: #define KJ_DBG(...) KJ_LOG(DBG, ##__VA_ARGS__)
cannam@62: 
cannam@62: #define KJ_REQUIRE(cond, ...) \
cannam@62:   if (KJ_LIKELY(cond)) {} else \
cannam@62:     for (::kj::_::Debug::Fault f(__FILE__, __LINE__, ::kj::Exception::Type::FAILED, \
cannam@62:                                  #cond, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_FAIL_REQUIRE(...) \
cannam@62:   for (::kj::_::Debug::Fault f(__FILE__, __LINE__, ::kj::Exception::Type::FAILED, \
cannam@62:                                nullptr, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_SYSCALL(call, ...) \
cannam@62:   if (auto _kjSyscallResult = ::kj::_::Debug::syscall([&](){return (call);}, false)) {} else \
cannam@62:     for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:              _kjSyscallResult.getErrorNumber(), #call, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_NONBLOCKING_SYSCALL(call, ...) \
cannam@62:   if (auto _kjSyscallResult = ::kj::_::Debug::syscall([&](){return (call);}, true)) {} else \
cannam@62:     for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:              _kjSyscallResult.getErrorNumber(), #call, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_FAIL_SYSCALL(code, errorNumber, ...) \
cannam@62:   for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:            errorNumber, code, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #if _WIN32
cannam@62: 
cannam@62: #define KJ_WIN32(call, ...) \
cannam@62:   if (::kj::_::Debug::isWin32Success(call)) {} else \
cannam@62:     for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:              ::kj::_::Debug::getWin32Error(), #call, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_WINSOCK(call, ...) \
cannam@62:   if ((call) != SOCKET_ERROR) {} else \
cannam@62:     for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:              ::kj::_::Debug::getWin32Error(), #call, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_FAIL_WIN32(code, errorNumber, ...) \
cannam@62:   for (::kj::_::Debug::Fault f(__FILE__, __LINE__, \
cannam@62:            ::kj::_::Debug::Win32Error(errorNumber), code, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #endif
cannam@62: 
cannam@62: #define KJ_UNIMPLEMENTED(...) \
cannam@62:   for (::kj::_::Debug::Fault f(__FILE__, __LINE__, ::kj::Exception::Type::UNIMPLEMENTED, \
cannam@62:                                nullptr, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())
cannam@62: 
cannam@62: #define KJ_CONTEXT(...) \
cannam@62:   auto KJ_UNIQUE_NAME(_kjContextFunc) = [&]() -> ::kj::_::Debug::Context::Value { \
cannam@62:         return ::kj::_::Debug::Context::Value(__FILE__, __LINE__, \
cannam@62:             ::kj::_::Debug::makeDescription(#__VA_ARGS__, ##__VA_ARGS__)); \
cannam@62:       }; \
cannam@62:   ::kj::_::Debug::ContextImpl<decltype(KJ_UNIQUE_NAME(_kjContextFunc))> \
cannam@62:       KJ_UNIQUE_NAME(_kjContext)(KJ_UNIQUE_NAME(_kjContextFunc))
cannam@62: 
cannam@62: #define KJ_REQUIRE_NONNULL(value, ...) \
cannam@62:   (*({ \
cannam@62:     auto _kj_result = ::kj::_::readMaybe(value); \
cannam@62:     if (KJ_UNLIKELY(!_kj_result)) { \
cannam@62:       ::kj::_::Debug::Fault(__FILE__, __LINE__, ::kj::Exception::Type::FAILED, \
cannam@62:                             #value " != nullptr", #__VA_ARGS__, ##__VA_ARGS__).fatal(); \
cannam@62:     } \
cannam@62:     kj::mv(_kj_result); \
cannam@62:   }))
cannam@62: 
cannam@62: #define KJ_EXCEPTION(type, ...) \
cannam@62:   ::kj::Exception(::kj::Exception::Type::type, __FILE__, __LINE__, \
cannam@62:       ::kj::_::Debug::makeDescription(#__VA_ARGS__, ##__VA_ARGS__))
cannam@62: 
cannam@62: #endif
cannam@62: 
cannam@62: #define KJ_SYSCALL_HANDLE_ERRORS(call) \
cannam@62:   if (int _kjSyscallError = ::kj::_::Debug::syscallError([&](){return (call);}, false)) \
cannam@62:     switch (int error = _kjSyscallError)
cannam@62: // Like KJ_SYSCALL, but doesn't throw. Instead, the block after the macro is a switch block on the
cannam@62: // error. Additionally, the int value `error` is defined within the block. So you can do:
cannam@62: //
cannam@62: //     KJ_SYSCALL_HANDLE_ERRORS(foo()) {
cannam@62: //       case ENOENT:
cannam@62: //         handleNoSuchFile();
cannam@62: //         break;
cannam@62: //       case EEXIST:
cannam@62: //         handleExists();
cannam@62: //         break;
cannam@62: //       default:
cannam@62: //         KJ_FAIL_SYSCALL("foo()", error);
cannam@62: //     } else {
cannam@62: //       handleSuccessCase();
cannam@62: //     }
cannam@62: 
cannam@62: #define KJ_ASSERT KJ_REQUIRE
cannam@62: #define KJ_FAIL_ASSERT KJ_FAIL_REQUIRE
cannam@62: #define KJ_ASSERT_NONNULL KJ_REQUIRE_NONNULL
cannam@62: // Use "ASSERT" in place of "REQUIRE" when the problem is local to the immediate surrounding code.
cannam@62: // That is, if the assert ever fails, it indicates that the immediate surrounding code is broken.
cannam@62: 
cannam@62: #ifdef KJ_DEBUG
cannam@62: #define KJ_DLOG KJ_LOG
cannam@62: #define KJ_DASSERT KJ_ASSERT
cannam@62: #define KJ_DREQUIRE KJ_REQUIRE
cannam@62: #else
cannam@62: #define KJ_DLOG(...) do {} while (false)
cannam@62: #define KJ_DASSERT(...) do {} while (false)
cannam@62: #define KJ_DREQUIRE(...) do {} while (false)
cannam@62: #endif
cannam@62: 
cannam@62: namespace _ {  // private
cannam@62: 
cannam@62: class Debug {
cannam@62: public:
cannam@62:   Debug() = delete;
cannam@62: 
cannam@62:   typedef LogSeverity Severity;  // backwards-compatibility
cannam@62: 
cannam@62: #if _WIN32
cannam@62:   struct Win32Error {
cannam@62:     // Hack for overloading purposes.
cannam@62:     uint number;
cannam@62:     inline explicit Win32Error(uint number): number(number) {}
cannam@62:   };
cannam@62: #endif
cannam@62: 
cannam@62:   static inline bool shouldLog(LogSeverity severity) { return severity >= minSeverity; }
cannam@62:   // Returns whether messages of the given severity should be logged.
cannam@62: 
cannam@62:   static inline void setLogLevel(LogSeverity severity) { minSeverity = severity; }
cannam@62:   // Set the minimum message severity which will be logged.
cannam@62:   //
cannam@62:   // TODO(someday):  Expose publicly.
cannam@62: 
cannam@62:   template <typename... Params>
cannam@62:   static void log(const char* file, int line, LogSeverity severity, const char* macroArgs,
cannam@62:                   Params&&... params);
cannam@62: 
cannam@62:   class Fault {
cannam@62:   public:
cannam@62:     template <typename Code, typename... Params>
cannam@62:     Fault(const char* file, int line, Code code,
cannam@62:           const char* condition, const char* macroArgs, Params&&... params);
cannam@62:     Fault(const char* file, int line, Exception::Type type,
cannam@62:           const char* condition, const char* macroArgs);
cannam@62:     Fault(const char* file, int line, int osErrorNumber,
cannam@62:           const char* condition, const char* macroArgs);
cannam@62: #if _WIN32
cannam@62:     Fault(const char* file, int line, Win32Error osErrorNumber,
cannam@62:           const char* condition, const char* macroArgs);
cannam@62: #endif
cannam@62:     ~Fault() noexcept(false);
cannam@62: 
cannam@62:     KJ_NOINLINE KJ_NORETURN(void fatal());
cannam@62:     // Throw the exception.
cannam@62: 
cannam@62:   private:
cannam@62:     void init(const char* file, int line, Exception::Type type,
cannam@62:               const char* condition, const char* macroArgs, ArrayPtr<String> argValues);
cannam@62:     void init(const char* file, int line, int osErrorNumber,
cannam@62:               const char* condition, const char* macroArgs, ArrayPtr<String> argValues);
cannam@62: #if _WIN32
cannam@62:     void init(const char* file, int line, Win32Error osErrorNumber,
cannam@62:               const char* condition, const char* macroArgs, ArrayPtr<String> argValues);
cannam@62: #endif
cannam@62: 
cannam@62:     Exception* exception;
cannam@62:   };
cannam@62: 
cannam@62:   class SyscallResult {
cannam@62:   public:
cannam@62:     inline SyscallResult(int errorNumber): errorNumber(errorNumber) {}
cannam@62:     inline operator void*() { return errorNumber == 0 ? this : nullptr; }
cannam@62:     inline int getErrorNumber() { return errorNumber; }
cannam@62: 
cannam@62:   private:
cannam@62:     int errorNumber;
cannam@62:   };
cannam@62: 
cannam@62:   template <typename Call>
cannam@62:   static SyscallResult syscall(Call&& call, bool nonblocking);
cannam@62:   template <typename Call>
cannam@62:   static int syscallError(Call&& call, bool nonblocking);
cannam@62: 
cannam@62: #if _WIN32
cannam@62:   static bool isWin32Success(int boolean);
cannam@62:   static bool isWin32Success(void* handle);
cannam@62:   static Win32Error getWin32Error();
cannam@62: #endif
cannam@62: 
cannam@62:   class Context: public ExceptionCallback {
cannam@62:   public:
cannam@62:     Context();
cannam@62:     KJ_DISALLOW_COPY(Context);
cannam@62:     virtual ~Context() noexcept(false);
cannam@62: 
cannam@62:     struct Value {
cannam@62:       const char* file;
cannam@62:       int line;
cannam@62:       String description;
cannam@62: 
cannam@62:       inline Value(const char* file, int line, String&& description)
cannam@62:           : file(file), line(line), description(mv(description)) {}
cannam@62:     };
cannam@62: 
cannam@62:     virtual Value evaluate() = 0;
cannam@62: 
cannam@62:     virtual void onRecoverableException(Exception&& exception) override;
cannam@62:     virtual void onFatalException(Exception&& exception) override;
cannam@62:     virtual void logMessage(LogSeverity severity, const char* file, int line, int contextDepth,
cannam@62:                             String&& text) override;
cannam@62: 
cannam@62:   private:
cannam@62:     bool logged;
cannam@62:     Maybe<Value> value;
cannam@62: 
cannam@62:     Value ensureInitialized();
cannam@62:   };
cannam@62: 
cannam@62:   template <typename Func>
cannam@62:   class ContextImpl: public Context {
cannam@62:   public:
cannam@62:     inline ContextImpl(Func& func): func(func) {}
cannam@62:     KJ_DISALLOW_COPY(ContextImpl);
cannam@62: 
cannam@62:     Value evaluate() override {
cannam@62:       return func();
cannam@62:     }
cannam@62:   private:
cannam@62:     Func& func;
cannam@62:   };
cannam@62: 
cannam@62:   template <typename... Params>
cannam@62:   static String makeDescription(const char* macroArgs, Params&&... params);
cannam@62: 
cannam@62: private:
cannam@62:   static LogSeverity minSeverity;
cannam@62: 
cannam@62:   static void logInternal(const char* file, int line, LogSeverity severity, const char* macroArgs,
cannam@62:                           ArrayPtr<String> argValues);
cannam@62:   static String makeDescriptionInternal(const char* macroArgs, ArrayPtr<String> argValues);
cannam@62: 
cannam@62:   static int getOsErrorNumber(bool nonblocking);
cannam@62:   // Get the error code of the last error (e.g. from errno).  Returns -1 on EINTR.
cannam@62: };
cannam@62: 
cannam@62: template <typename... Params>
cannam@62: void Debug::log(const char* file, int line, LogSeverity severity, const char* macroArgs,
cannam@62:                 Params&&... params) {
cannam@62:   String argValues[sizeof...(Params)] = {str(params)...};
cannam@62:   logInternal(file, line, severity, macroArgs, arrayPtr(argValues, sizeof...(Params)));
cannam@62: }
cannam@62: 
cannam@62: template <>
cannam@62: inline void Debug::log<>(const char* file, int line, LogSeverity severity, const char* macroArgs) {
cannam@62:   logInternal(file, line, severity, macroArgs, nullptr);
cannam@62: }
cannam@62: 
cannam@62: template <typename Code, typename... Params>
cannam@62: Debug::Fault::Fault(const char* file, int line, Code code,
cannam@62:                     const char* condition, const char* macroArgs, Params&&... params)
cannam@62:     : exception(nullptr) {
cannam@62:   String argValues[sizeof...(Params)] = {str(params)...};
cannam@62:   init(file, line, code, condition, macroArgs,
cannam@62:        arrayPtr(argValues, sizeof...(Params)));
cannam@62: }
cannam@62: 
cannam@62: inline Debug::Fault::Fault(const char* file, int line, int osErrorNumber,
cannam@62:                            const char* condition, const char* macroArgs)
cannam@62:     : exception(nullptr) {
cannam@62:   init(file, line, osErrorNumber, condition, macroArgs, nullptr);
cannam@62: }
cannam@62: 
cannam@62: inline Debug::Fault::Fault(const char* file, int line, kj::Exception::Type type,
cannam@62:                            const char* condition, const char* macroArgs)
cannam@62:     : exception(nullptr) {
cannam@62:   init(file, line, type, condition, macroArgs, nullptr);
cannam@62: }
cannam@62: 
cannam@62: #if _WIN32
cannam@62: inline Debug::Fault::Fault(const char* file, int line, Win32Error osErrorNumber,
cannam@62:                            const char* condition, const char* macroArgs)
cannam@62:     : exception(nullptr) {
cannam@62:   init(file, line, osErrorNumber, condition, macroArgs, nullptr);
cannam@62: }
cannam@62: 
cannam@62: inline bool Debug::isWin32Success(int boolean) {
cannam@62:   return boolean;
cannam@62: }
cannam@62: inline bool Debug::isWin32Success(void* handle) {
cannam@62:   // Assume null and INVALID_HANDLE_VALUE mean failure.
cannam@62:   return handle != nullptr && handle != (void*)-1;
cannam@62: }
cannam@62: #endif
cannam@62: 
cannam@62: template <typename Call>
cannam@62: Debug::SyscallResult Debug::syscall(Call&& call, bool nonblocking) {
cannam@62:   while (call() < 0) {
cannam@62:     int errorNum = getOsErrorNumber(nonblocking);
cannam@62:     // getOsErrorNumber() returns -1 to indicate EINTR.
cannam@62:     // Also, if nonblocking is true, then it returns 0 on EAGAIN, which will then be treated as a
cannam@62:     // non-error.
cannam@62:     if (errorNum != -1) {
cannam@62:       return SyscallResult(errorNum);
cannam@62:     }
cannam@62:   }
cannam@62:   return SyscallResult(0);
cannam@62: }
cannam@62: 
cannam@62: template <typename Call>
cannam@62: int Debug::syscallError(Call&& call, bool nonblocking) {
cannam@62:   while (call() < 0) {
cannam@62:     int errorNum = getOsErrorNumber(nonblocking);
cannam@62:     // getOsErrorNumber() returns -1 to indicate EINTR.
cannam@62:     // Also, if nonblocking is true, then it returns 0 on EAGAIN, which will then be treated as a
cannam@62:     // non-error.
cannam@62:     if (errorNum != -1) {
cannam@62:       return errorNum;
cannam@62:     }
cannam@62:   }
cannam@62:   return 0;
cannam@62: }
cannam@62: 
cannam@62: template <typename... Params>
cannam@62: String Debug::makeDescription(const char* macroArgs, Params&&... params) {
cannam@62:   String argValues[sizeof...(Params)] = {str(params)...};
cannam@62:   return makeDescriptionInternal(macroArgs, arrayPtr(argValues, sizeof...(Params)));
cannam@62: }
cannam@62: 
cannam@62: template <>
cannam@62: inline String Debug::makeDescription<>(const char* macroArgs) {
cannam@62:   return makeDescriptionInternal(macroArgs, nullptr);
cannam@62: }
cannam@62: 
cannam@62: }  // namespace _ (private)
cannam@62: }  // namespace kj
cannam@62: 
cannam@62: #endif  // KJ_DEBUG_H_