#define _POSIX_C_SOURCE 200809L

#include "Core.h"

#include "Debug.h"

#include "DebugManager.h"

#include <algorithm>

#include <chrono>

#include <iomanip>

#include <thread>

#ifdef _MSC_VER

static tm* localtime_r(const time_t* time, tm* result)

{

localtime_s(result, time);

return result;

}

#endif

namespace DFHack {

DBG_DECLARE(core,debug);

void DebugManager::registerCategory(DebugCategory& cat)

}

void DebugManager::unregisterCategory(DebugCategory& cat)

}

DebugRegisterBase::DebugRegisterBase(DebugCategory* cat)

}

void DebugRegisterBase::unregister(DebugCategory* cat)

{

DebugManager::getInstance().unregisterCategory(*cat);

}

static color_value selectColor(const DebugCategory::level msgLevel)

}

#if __GNUC__

#define EXEC_ATTR __attribute__((tls_model("initial-exec")))

#else

#define EXEC_ATTR

#endif

namespace {

static std::atomic<uint32_t> nextId{0};

static EXEC_ATTR thread_local uint32_t thread_id{nextId.fetch_add(1)+1};

}

DebugCategory::ostream_proxy_prefix::ostream_proxy_prefix(

const DebugCategory& cat,

color_ostream& target,

const DebugCategory::level msgLevel) :

color_ostream_proxy(target)

{

DebugManager &dm = DebugManager::getInstance();

const DebugManager::HeaderConfig &config = dm.getHeaderConfig();

color(selectColor(msgLevel));

bool has_header = false;

if (config.timestamp) {

has_header = true;

auto now = std::chrono::system_clock::now();

tm local{};

//! \todo c++ 2020 will have std::chrono::to_stream(fmt, system_clock::now())

//! but none implements it yet.

std::time_t now_c = std::chrono::system_clock::to_time_t(now);

// Output time in format %02H:%02M:%02S.%03ms

#if __GNUC__ < 5

// Fallback for gcc 4

char buffer[32];

size_t sz = strftime(buffer, sizeof(buffer)/sizeof(buffer[0]),

"%T", localtime_r(&now_c, &local));

*this << (sz > 0 ? buffer : "HH:MM:SS");

#else

*this << std::put_time(localtime_r(&now_c, &local),"%T");

#endif

if (config.timestamp_ms) {

auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(

now.time_since_epoch()) % 1000;

*this << '.' << std::setfill('0') << std::setw(3) << ms.count();

}

*this << ':';

}

if (config.thread_id) {

has_header = true;

// Thread id is allocated in the thread creation order to a thread_local

// variable

*this << 't' << thread_id << ':';

}

if (config.plugin) {

has_header = true;

*this << cat.plugin() << ':';

}

if (config.category) {

has_header = true;

*this << cat.category() << ':';

}

// It would be easy to pass __FILE__ and __LINE__ from the logging macros

// and include that information as well, if we want to.

if (has_header) {

*this << ' ';

}

}

DebugCategory::level DebugCategory::allowed() const noexcept

{

return allowed_.load(std::memory_order_relaxed);

}

void DebugCategory::allowed(DebugCategory::level value) noexcept

}

DebugCategory::cstring_ref DebugCategory::category() const noexcept

{

return category_;

}

DebugCategory::cstring_ref DebugCategory::plugin() const noexcept

{

return plugin_;

}

#if __cplusplus < 201703L && __cpp_lib_atomic_is_always_lock_free < 201603

struct failIfEnumAtomicIsNotLockFree {

} failIfEnumAtomicIsNotLockFree;

#endif

}