m_size = 0;

namespace bq
{
    namespace internal
    {
    }
}

DECLARE_FUNC(One)
DECLARE_FUNC(Two)
DECLARE_FUNC(Three)

что_то_там_One_что_то_там
что_то_там_Two_что_то_там
что_то_там_Three_что_то_там

#pragma once
#ifndef __BQ_BADCOIQ_H__
#define __BQ_BADCOIQ_H__

#endif

build/badcoiq/.vs
build/badcoiq/x64
build/badcoiq/Debug
build/badcoiq/Release
*.idb
*.pdb
*.lib

#define ABC

#include <stddef.h> // NULL, size_t
#include <stdlib.h>
#include <assert.h>
#include <stdint.h> // int32_t uint32_t и другие
#include <ctype.h>  // isspace
#include <utility>  // std::move

#ifdef _MSC_VER
#define BQ_FORCEINLINE __forceinline
#else
#define BQ_FORCEINLINE inline
#endif

#define bqReal double

#if defined(WIN32) | defined(_WIN64) | defined(_WIN32)
#define BQ_PLATFORM_WINDOWS
#else
#error Только для Windows
#endif

#ifdef BQ_PLATFORM_WINDOWS
#define BQ_CDECL _cdecl
#else
#error Только для Windows
#endif

#ifdef _DEBUG
#define BQ_DEBUG
#endif

#define BQ_MAKEFOURCC( ch0, ch1, ch2, ch3 )\
    ((uint32_t)(uint8_t)(ch0)|((uint32_t)(uint8_t)(ch1)<<8)|\
    ((uint32_t)(uint8_t)(ch2)<<16)|((uint32_t)(uint8_t)(ch3)<<24))

#ifdef BQ_PLATFORM_WINDOWS
#if defined _WIN64 || defined __x86_64__
#define BQ_BIT_64
#endif
#else
#error Только для Windows
#endif

#ifdef BQ_PLATFORM_WINDOWS
#define BQ_FILE __FILE__
#define BQ_LINE __LINE__
#define BQ_FUNCTION __FUNCTION__
#else
#error Только для Windows
#endif

#ifdef _MSC_VER

// Версия компилятора Visual Studio
#if _MSC_VER >= 1930 && _MSC_VER <= 1936
#define BQ_LINK_LIBRARY_CMP "_v143"
#elif _MSC_VER >= 1920 && _MSC_VER <= 1929
#define BQ_LINK_LIBRARY_CMP "_v142"
#elif _MSC_VER >= 1910 && _MSC_VER <= 1916
#error Не проверено.
#define BQ_LINK_LIBRARY_CMP "_v141"
#endif

#ifdef BQ_BIT_64
#define BQ_LINK_LIBRARY_ARCH "_x64"
#else
#define BQ_LINK_LIBRARY_ARCH "_x86"
#endif

#ifdef BQ_DEBUG
#define BQ_LINK_LIBRARY_CONF "_Debug"
#else
#define BQ_LINK_LIBRARY_CONF "_Release"
#endif

// Использование : BQ_LINK_LIBRARY("libname")
#define BQ_LINK_LIBRARY(n) \
    __pragma(comment(lib, n BQ_LINK_LIBRARY_CMP BQ_LINK_LIBRARY_ARCH BQ_LINK_LIBRARY_CONF ".lib"))

#endif

#define BQ_LO32(l) ((uint16_t)(((uint32_t)(l)) & 0xffff))
#define BQ_HI32(l) ((uint16_t)((((uint32_t)(l)) >> 16) & 0xffff))

#include "badcoiq/common/bqDefines.h"

class bqMemory
{
public:
    static void* malloc(size_t size);
    static void* calloc(size_t size);
    static void  free(void*);
    static void* realloc(void*, size_t size);
};

#include "badcoiq.h"

#ifdef BQ_PLATFORM_WINDOWS
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
// Windows функции для работы с памятью требуют Process Heap
// Ничего страшного в глобальной переменной нет.
static HANDLE g_processHeap = GetProcessHeap();
#endif

void* bqMemory::malloc(size_t size)
{
#ifdef BQ_PLATFORM_WINDOWS
    return HeapAlloc(g_processHeap, 0, size);
#else
    return ::malloc(size);
#endif
}

void* bqMemory::calloc(size_t size)
{
#ifdef BQ_PLATFORM_WINDOWS
    return HeapAlloc(g_processHeap, HEAP_ZERO_MEMORY, size);
#else
    return ::calloc(1, size);
#endif
}

void bqMemory::free(void* ptr)
{
#ifdef BQ_PLATFORM_WINDOWS
    HeapFree(g_processHeap, 0, ptr);
#else
    ::free(ptr);
#endif
}

void* bqMemory::realloc(void* ptr, size_t size)
{
#ifdef BQ_PLATFORM_WINDOWS
    return HeapReAlloc(g_processHeap, HEAP_ZERO_MEMORY, ptr, size);
#else
    return ::realloc(ptr, size);
#endif
}

template<typename _type, typename... Args>
_type* bqCreate(Args&&... args)
{
    _type* ptr = (_type*)bqMemory::malloc(sizeof(_type));
    if (ptr)
  ::new(ptr) _type(std::forward<Args>(args)...);// вызов конструктора
    return ptr;
}

template<typename _type>
void bqDestroy(_type* ptr)
{
    assert(ptr);
    ptr->~_type();// вызов деструктора
    bqMemory::free(ptr);
}

MyClass* o = bqCreate<MyClass>(param1, param2, param3);
if(o)
    bqDestroy(o);

#define BQ_PLACEMENT_ALLOCATOR(c) void* operator new(std::size_t count){ return (c*)bqMemory::malloc(count);}\
void operator delete(void* ptr){if (ptr) bqDestroy(ptr);}

class MyClass
{
public:
    MyClass(){
  printf("C1\n");
    }

    MyClass(int a, int b, int c){
  printf("C2\n");
    }

    ~MyClass(){
  printf("D\n");
    }

    BQ_PLACEMENT_ALLOCATOR(MyClass);
};

void f()
{
    /*MyClass* o = bqCreate<MyClass>();
    if (o)
  bqDestroy(o);*/

    MyClass* o = new MyClass(1,2,3);
    if (o)
  delete o;
}

// надо завести свои имена для хэндла и указателя на функцию
typedef void* bqDLLHandle;   // HMODULE в Windows
typedef void* bqDLLFunction;

class bqDLL
{
public:

    // Загрузить динамическую библиотеку
    // Вернётся указатель если загрузилось.
    // При завершении работы надо вызвать free и передать bqDLLHandle
    static bqDLLHandle load(const char* libraryName);

    // Выгрузить библиотеку
    static void free(bqDLLHandle library);

    // Получить функцию из библиотеки
    // Вернёт NULL если была какая-то ошибка.
    static bqDLLFunction get_proc(bqDLLHandle library, const char* functionName);
};

#include "badcoiq.h"

#ifdef BQ_PLATFORM_WINDOWS
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#endif

bqDLLHandle bqDLL::load(const char* libraryName)
{
    BQ_ASSERT_ST(libraryName);
#ifdef BQ_PLATFORM_WINDOWS
    return (bqDLLHandle)LoadLibraryA(libraryName);
#else
#error Для Windows
#endif
}

void bqDLL::free(bqDLLHandle library)
{
    BQ_ASSERT_ST(library);
#ifdef BQ_PLATFORM_WINDOWS
    FreeLibrary((HMODULE)library);
#else
#error Для Windows
#endif
}

bqDLLFunction bqDLL::get_proc(bqDLLHandle library, const char* functionName)
{
    BQ_ASSERT_ST(library);
    BQ_ASSERT_ST(functionName);
#ifdef BQ_PLATFORM_WINDOWS
    return (bqDLLFunction)GetProcAddress((HMODULE)library, functionName);
#else
#error Для Windows
#endif
}

#ifdef BQ_DEBUG
#define BQ_ASSERT(expression) if((expression) == 0){bq::internal::OnAssert(#expression, BQ_FILE, BQ_LINE, 0);}
#define BQ_ASSERT_ST(expression) if((expression) == 0){bq::internal::OnAssert(#expression, BQ_FILE, BQ_LINE, bq::internal::flag_onAssert_useDefaultSystemWindow | bq::internal::flag_onAssert_useStackTrace);}
#else
#define BQ_ASSERT(expression) ((void)0)
#define BQ_ASSERT_ST(expression) ((void)0)
#endif

// Скрою в неймспейсах вспомогательные функции
namespace bq
{
    namespace internal
    {
        enum flag_onAssert
        {
            // использовать системное окно которое показывается как при использовании assert()
            flag_onAssert_useDefaultSystemWindow = 0x1,

            // использовать stack tracer
            flag_onAssert_useStackTrace = 0x2,
        };

        // макросы BQ_ASSERT будут вызывать эту функцию
        void BQ_CDECL OnAssert(const char* message, const char* file, uint32_t line, uint32_t flags = 0);
  
  // установить свою функцию
        void BQ_CDECL SetOnAssert(void(*)(const char* message, const char* file, uint32_t line, uint32_t flags));
    }
}

#include "badcoiq.h"

#ifdef BQ_PLATFORM_WINDOWS
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#endif

// Дефолтная функция для assert
// Надо раздокументировать когда будут готовы log, stacktracer и string
void bqOnAssert_default(const char* message, const char* file, uint32_t line, uint32_t flags)
{
#ifdef BQ_DEBUG
    if ((flags & bq::internal::flag_onAssert_useStackTrace) == bq::internal::flag_onAssert_useStackTrace)
    {
        //bqStackTracer::Print();
    }

    if ((flags & bq::internal::flag_onAssert_useDefaultSystemWindow) == bq::internal::flag_onAssert_useDefaultSystemWindow)
    {
        //bqString str_msg(message);
        //bqString str_file(file);

        //bqStringW str1;
        //str_msg.to_utf16(str1);

        //bqStringW str2;
        //str_file.to_utf16(str2);

#ifdef BQ_PLATFORM_WINDOWS
        //_wassert((const wchar_t*)str1.m_data, (const wchar_t*)str2.m_data, line);
#endif
    }
    else
    {
        //printf("%s %s %i\n", message, file, line);
       //bqlLog::PrintError("%s %s %i\n", message, file, line);
#ifdef BQ_PLATFORM_WINDOWS
        DebugBreak();
#endif
    }
#endif
}

// Указатель на функцию. Можно будет изменять функцию OnAssert используя функцию SetOnAssert
static void(*g_onAssert)(const char* message, const char* file, uint32_t line, uint32_t flags) = bqOnAssert_default;

namespace bq
{
    namespace internal
    {
        // просто вызываем g_onAssert
        void BQ_CDECL OnAssert(const char* message, const char* file, uint32_t line, uint32_t flags)
        {
            g_onAssert(message, file, line, flags);
        }
    
        // Изменяем g_onAssert. Или устанавливаем дефолтную функцию.
        void BQ_CDECL SetOnAssert(void(*f)(const char* message, const char* file, uint32_t line, uint32_t flags))
        {
            g_onAssert = f ? f : bqOnAssert_default;
        }
    }
}

void _reallocate(size_t new_allocated)
{
    // выделение новой памяти, копирование содержимого, освобождение старой, сохранение нового указателя
    char_type* new_data = (char_type*)bqMemory::malloc(new_allocated * sizeof(char_type));
    if (m_data)
    {
  memcpy(new_data, m_data, m_size * sizeof(char_type));
  bqMemory::free(m_data);
    }
    else
    {
  memset(new_data, 0, new_allocated);
    }
    m_data = new_data;
    m_allocated = new_allocated;
}

template<typename other_type>
bqString_base(const other_type* str)
{
    _reallocate(m_allocated);
    assign(str); // просто присвоение
}
...
// присвоить содержимое другой строки
template<typename other_type>
void assign(other_type str)
{
    clear();
    if (str)
  append(str);
}
...
template<typename other_type>
void append(const other_type* str)
{
    append(str, bqStringLen(str));
}
...
// добавить в конец
template<typename other_type>
void append(const other_type* str, size_t l)
{
    for (size_t i = 0; i < l; ++i)
    {
  push_back((char_type)str[i]);
    }
}
...
// добавить в конец символ
void push_back(char_type c)
{
    size_t new_size = m_size + 1u;
    if ((new_size + 1u) > m_allocated)
  _reallocate((new_size + 1u) + (1 + (uint32_t)(m_size * 0.5f)));
    m_data[m_size] = c;
    m_size = new_size;
    m_data[m_size] = 0;
}

void append(float f)
{
    char buf[32];
    int nob = sprintf_s(buf, 32, "%.4f", f);
    if (nob)
    {
  for (int i = 0; i < nob; ++i)
  {
   push_back((char_type)buf[i]);
  }
    }
}

struct slUnicodeCharNode
{
    uint32_t m_utf8; // код для UTF-8
    uint32_t m_utf16;// код для UTF-16
};
static slUnicodeCharNode g_UnicodeChars[0x32000] =
{
#include "UnicodeChars.inl" // коды здесь
};

// UTF-8 to UTF-32
void bqString::append(const char* str)
{
    size_t len = bqStringLen(str);

    unsigned char c1 = 0;
    unsigned char c2 = 0;
    unsigned char c3 = 0;
    unsigned char c4 = 0;
    for (size_t i = 0; i < len; ++i)
    {
  c1 = str[i];

  if (c1 <= 0x7F)
  {
   push_back((char32_t)c1);
  }
  else
  {
   if ((c1 & 0xE0) == 0xC0) //2 bytes
   {
    ++i;
    if (i < len)
    {
     c2 = str[i];
     if ((c2 & 0xC0) == 0x80)
     {
      char16_t wch = (c1 & 0x1F) << 6;
      wch |= (c2 & 0x3F);
      push_back((char32_t)wch);
     }
    }
   }
   else if ((c1 & 0xF0) == 0xE0) //3
   {
    ++i;
    if (i < len)
    {
     c2 = str[i];
     if ((c2 & 0xC0) == 0x80)
     {
      ++i;
      if (i < len)
      {
       c3 = str[i];
       if ((c3 & 0xC0) == 0x80)
       {
        char16_t wch = (c1 & 0xF) << 12;
        wch |= (c2 & 0x3F) << 6;
        wch |= (c3 & 0x3F);
        push_back((char32_t)wch);
       }
      }
     }
    }
   }
   else if ((c1 & 0xF8) == 0xF0) //4
   {
    ++i;
    if (i < len)
    {
     c2 = str[i];
     if ((c2 & 0xC0) == 0x80)
     {
      ++i;
      if (i < len)
      {
       c3 = str[i];
       if ((c3 & 0xC0) == 0x80)
       {
        ++i;
        if (i < len)
        {
         c4 = str[i];
         if ((c4 & 0xC0) == 0x80)
         {
                              uint32_t u = (c1 & 0x7) << 18;
                              u |= (c2 & 0x3F) << 12;
                              u |= (c3 & 0x3F) << 6;
                              u |= (c4 & 0x3F);

                              push_back((char32_t)u);
         }
        }
       }
      }
     }
    }
   }
  }
    }
}

// UTF-16 to UTF-32
void bqString::append(const wchar_t* str)
{
    size_t len = bqStringLen(str);
    for (size_t i = 0u; i < len; ++i)
    {
  char16_t ch16 = str[i];
  if (ch16 < 0x80)
  {
   push_back((char32_t)ch16);
  }
  else if (ch16 < 0x800)
  {
   push_back((char32_t)ch16); //????
  }
  else if ((ch16 & 0xFC00) == 0xD800)
  {
   ++i;
   if (i < len)
   {
    char16_t ch16_2 = str[i];
    if ((ch16_2 & 0xFC00) == 0xDC00)
    {
     uint32_t u = (ch16 - 0xD800) * 0x400;
     u += (ch16_2 - 0xDC00) + 0x10000;

     push_back((char32_t)u);
    }
   }
  }
  else
  {
   push_back((char32_t)ch16);
  }
    }
}

// для to_utf8 to_utf16.
union UC
{
    uint8_t bytes[4];
    uint16_t shorts[2];
    uint32_t integer;
};
...
void bqString::to_utf8(bqStringA& stra) const
{
    stra.clear();
    UC uc;
    auto ut = &g_UnicodeChars[0];
    for (size_t i = 0; i < m_size; ++i)
    {
  char32_t c = m_data[i];
  if (c >= 0x32000)
   c = '?';

  uc.integer = ut[c].m_utf8;

  if (uc.bytes[3]) stra.push_back(uc.bytes[3]);
  if (uc.bytes[2]) stra.push_back(uc.bytes[2]);
  if (uc.bytes[1]) stra.push_back(uc.bytes[1]);
  if (uc.bytes[0]) stra.push_back(uc.bytes[0]);
    }
}

void bqString::to_utf16(bqStringW& strw) const
{
    strw.clear();
    UC uc;
    auto ut = &g_UnicodeChars[0];
    for (size_t i = 0; i < m_size; ++i)
    {
  char32_t c = m_data[i];
  if (c >= 0x32000)
   c = '?';

  uc.integer = ut[c].m_utf16;

  if (uc.shorts[1]) strw.push_back(uc.shorts[1]);
  if (uc.shorts[0]) strw.push_back(uc.shorts[0]);
    }
}

C:\Code\badcoiq\src\badcoiq\system\bqStacktracer.cpp(190):'bqStackTracerImpl::GetStackTrace'
C:\Code\badcoiq\src\badcoiq\system\bqStacktracer.cpp(200):'bqStackTracer::Print'
C:\Code\badcoiqConsoleApplication1\badcoiqConsoleApplication1.cpp(9):'main'
D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl(78):'invoke_main'
D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl(288):'__scrt_common_main_seh'
D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl(331):'__scrt_common_main'
D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_main.cpp(17):'mainCRTStartup'
(null)(0):'BaseThreadInitThunk'
(null)(0):'RtlGetAppContainerNamedObjectPath'
(null)(0):'RtlGetAppContainerNamedObjectPath'
(null)(0):'(unknown)'

class bqStackTracer
{
public:
    static void Print();
};

#include "badcoiq.h"

#ifdef BQ_PLATFORM_WINDOWS
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <dbghelp.h>
typedef BOOL(__stdcall* tSymInitialize)(HANDLE hProcess, PSTR UserSearchPath, BOOL fInvadeProcess);
typedef BOOL(__stdcall* tSymCleanup)(HANDLE hProcess);
typedef DWORD(__stdcall* tSymGetOptions)();
typedef DWORD(__stdcall* tSymSetOptions)(DWORD SymOptions);
typedef BOOL(__stdcall* tSymFromAddr)(HANDLE hProcess, DWORD64 dwAddr, PDWORD64 pdwDisplacement, PSYMBOL_INFO Symbol);
typedef BOOL(__stdcall* tSymGetLineFromAddr64)(HANDLE hProcess, DWORD64 dwAddr, PDWORD64 pdwDisplacement, PIMAGEHLP_LINE64 Line);
typedef void(__stdcall* tRtlCaptureContext)(PCONTEXT context);
typedef USHORT(__stdcall* tRtlCaptureStackBackTrace)(ULONG FramesToSkip, ULONG FramesToCapture, PVOID* BackTrace, PULONG BackTraceHash);
#endif

class bqStackTracerImpl
{
    void _init();
public:
    bqStackTracerImpl();
    ~bqStackTracerImpl();

    void DumpStackTrace(const size_t* trace, int numtrace);
    int  GetStackTrace(size_t* trace, int maxtrace, int framesToSkip = 0);

    CRITICAL_SECTION m_lock;
    bool m_lockInitialized = false;
    bool m_initialized = false;
    HINSTANCE m_DbgHelpDll = 0;
    HINSTANCE m_Kernel32Dll = 0;
    tSymInitialize m_SymInitialize = 0;
    tSymCleanup m_SymCleanup = 0;
    tSymGetOptions m_SymGetOptions = 0;
    tSymSetOptions m_SymSetOptions = 0;
    tSymFromAddr m_SymFromAddr = 0;
    tSymGetLineFromAddr64 m_SymGetLineFromAddr64 = 0;
    tRtlCaptureContext m_RtlCaptureContext = 0;
    tRtlCaptureStackBackTrace m_RtlCaptureStackBackTrace = 0;
};

#define LOAD_FUNCTION(A) if(1) { m_##A = (t##A) GetProcAddress(m_DbgHelpDll, #A); } else
#define LOAD_FUNCTION_WARN(A) if(1) { m_##A = (t##A) GetProcAddress(m_DbgHelpDll, #A); NATIVE_WARN_IF( m_##A == NULL, "Could not load symbol " #A " from dbghelp.dll, version too old, but will continue without it."); } else

bqStackTracerImpl::bqStackTracerImpl()
{
    InitializeCriticalSection(&m_lock);
    m_lockInitialized = true;
}

bqStackTracerImpl::~bqStackTracerImpl()
{
    m_lockInitialized = false;
    DeleteCriticalSection(&m_lock);
    m_SymCleanup(GetCurrentProcess());
    if (m_DbgHelpDll)
  FreeLibrary(m_DbgHelpDll);
    if (m_Kernel32Dll)
  FreeLibrary(m_Kernel32Dll);
}

void bqStackTracerImpl::_init()
{
    if (!m_initialized)
    {
  EnterCriticalSection(&m_lock);
  if (!m_initialized)
  {
   m_DbgHelpDll = LoadLibraryA("dbghelp.dll");
   if (m_DbgHelpDll)
   {
    m_Kernel32Dll = LoadLibraryA("kernel32.dll");
    if (m_Kernel32Dll)
    {
     LOAD_FUNCTION(SymInitialize);
     LOAD_FUNCTION(SymCleanup);
     LOAD_FUNCTION(SymGetOptions);
     LOAD_FUNCTION(SymSetOptions);
     LOAD_FUNCTION(SymFromAddr);
     LOAD_FUNCTION(SymGetLineFromAddr64);

     m_RtlCaptureContext = (tRtlCaptureContext)GetProcAddress(m_Kernel32Dll, "RtlCaptureContext");
     m_RtlCaptureStackBackTrace = (tRtlCaptureStackBackTrace)GetProcAddress(m_Kernel32Dll, "RtlCaptureStackBackTrace");

     DWORD symOptions = m_SymGetOptions();
     symOptions |= SYMOPT_LOAD_LINES | SYMOPT_DEBUG | SYMOPT_DEFERRED_LOADS;
     m_SymSetOptions(symOptions);

     UINT prevErrMode = GetErrorMode();
     SetErrorMode(SEM_FAILCRITICALERRORS);
     BOOL initsymbols = m_SymInitialize(GetCurrentProcess(), NULL, TRUE);
     if (initsymbols == TRUE)
     {
      SetErrorMode(prevErrMode);
      m_initialized = true;
     }
    }
   }
  }
  LeaveCriticalSection(&m_lock);
    }

    if (!m_initialized)
    {
  if(m_DbgHelpDll)
   FreeLibrary(m_DbgHelpDll);
  if(m_Kernel32Dll)
   FreeLibrary(m_Kernel32Dll);
  m_DbgHelpDll = 0;
  m_Kernel32Dll = 0;
    }
}

void bqStackTracerImpl::DumpStackTrace(const size_t* trace, int maxtrace)
{
    _init();

    SYMBOL_INFO_PACKAGE sym;
    sym.si.SizeOfStruct = sizeof(sym.si);
    sym.si.MaxNameLen = sizeof(sym.name);

    HANDLE curproc = GetCurrentProcess();

    for (int i = 0; i < maxtrace; ++i)
    {
  uint64_t symaddress = trace[i];

  DWORD64 displacement = 0;
  BOOL ok_symbol = m_SymFromAddr(
   curproc,
   DWORD64(symaddress),
   &displacement,
   &sym.si);

  if (!ok_symbol)
   ::strcpy_s(sym.si.Name, 2000, "(unknown)");
  IMAGEHLP_LINE64 line;
  ::memset(&line, 0, sizeof(line));
  line.SizeOfStruct = sizeof(line);

  m_SymGetLineFromAddr64(
   curproc,
   DWORD64(symaddress),
   &displacement,
   &line);

  char trace[2048];
  _snprintf_s(trace, 2048, "%s(%i):'%s'\n", line.FileName, line.LineNumber, sym.si.Name);
  printf(trace);
  //bqLog::Print("%s\n", trace);
    }
}

int bqStackTracerImpl::GetStackTrace(size_t* trace, int maxtrace, int framesToSkip)
{
    _init();
    if (m_RtlCaptureStackBackTrace)
  return m_RtlCaptureStackBackTrace(framesToSkip, maxtrace, (PVOID*)trace, NULL);
    return 0;
}

static bqStackTracerImpl g_stackTracer;

void bqStackTracer::Print()
{
    size_t t[100];
    g_stackTracer.DumpStackTrace(t, g_stackTracer.GetStackTrace(t, 100, 0));
}

// не забыть указать inc и libs папки в параметрах проекта
#include "badcoiq.h"

BQ_LINK_LIBRARY("badcoiq");

int main()
{
    bqStackTracer::Print();
    
    return EXIT_SUCCESS;
}

// Класс для вывода текстового сообщения
// Можно установить коллбэки
class bqLog
{
public:
    static void Print(const char* s, ...);
    static void Print(const wchar_t* s, ...);

    static void PrintInfo(const char* s, ...);
    static void PrintInfo(const wchar_t* s, ...);

    static void PrintWarning(const char* s, ...);
    static void PrintWarning(const wchar_t* s, ...);

    static void PrintError(const char* s, ...);
    static void PrintError(const wchar_t* s, ...);

    static void SetCallbackA(void(*)(const char*));
    static void SetCallbackW(void(*)(const wchar_t*));
};

#include <stdarg.h>

void bqLogDefaultCallbackA(const char* s)
{
    printf(s);
}

void bqLogDefaultCallbackW(const wchar_t* s)
{
    wprintf(s);
}

class bqLogImpl
{
public:
    bqLogImpl()
    {
  m_cba = bqLogDefaultCallbackA;
  m_cbw = bqLogDefaultCallbackW;
    }

    void vprintf(const char* s, va_list vl);
    void vwprintf(const wchar_t* s, va_list vl);

    void(*m_cba)(const char*);
    void(*m_cbw)(const wchar_t*);
};

void bqLogImpl::vprintf(const char* s, va_list vl)
{
    char buffer[0xFFFF];
    vsnprintf_s(buffer, 0xFFFF, s, vl);
    m_cba(buffer);
}

void bqLogImpl::vwprintf(const wchar_t* s, va_list vl)
{
    wchar_t buffer[0xFFFF];
    vswprintf_s(buffer, 0xFFFF, s, vl);
    m_cbw(buffer);
}

static bqLogImpl g_log;

void bqLog::Print(const char* s, ...)
{
    va_list vl;
    va_start(vl, s);
    g_log.vprintf(s, vl);
    va_end(vl);
}

void bqLog::Print(const wchar_t* s, ...)
{
    va_list vl;
    va_start(vl, s);
    g_log.vwprintf(s, vl);
    va_end(vl);
}

void bqLog::PrintInfo(const char* s, ...)
{
    Print("%s", "Info: ");

    va_list vl;
    va_start(vl, s);
    g_log.vprintf(s, vl);
    va_end(vl);
}

void bqLog::PrintInfo(const wchar_t* s, ...)
{
    Print("%s", "Info: ");
    va_list vl;
    va_start(vl, s);
    g_log.vwprintf(s, vl);
    va_end(vl);
}

void bqLog::PrintWarning(const char* s, ...)
{
    Print("%s", "Warning: ");
    va_list vl;
    va_start(vl, s);
    g_log.vprintf(s, vl);
    va_end(vl);
}

void bqLog::PrintWarning(const wchar_t* s, ...)
{
    Print("%s", "Warning: ");
    va_list vl;
    va_start(vl, s);
    g_log.vwprintf(s, vl);
    va_end(vl);
}

void bqLog::PrintError(const char* s, ...)
{
    Print("%s", "Error: ");
    va_list vl;
    va_start(vl, s);
    g_log.vprintf(s, vl);
    va_end(vl);
}

void bqLog::PrintError(const wchar_t* s, ...)
{
    Print("%s", "Error: ");
    va_list vl;
    va_start(vl, s);
    g_log.vwprintf(s, vl);
    va_end(vl);
}

void bqLog::SetCallbackA(void(*cb)(const char*))
{
    if (cb)
  g_log.m_cba = cb;
    else
  g_log.m_cba = bqLogDefaultCallbackA;
}

void bqLog::SetCallbackW(void(*cb)(const wchar_t*))
{
    if (cb)
  g_log.m_cbw = cb;
    else
  g_log.m_cbw = bqLogDefaultCallbackW;
}

class bqWindow;
class bqWindowCallback;

class CClass{
...
    MyObject m_object;
};

class MyObject; //forward declaration
class CClass{
...
    MyObject* m_object = 0;
};

// Предполагаю что фреймворк должен посылать какие-то сообщения.
// Я это ещё не реализовал
class bqFrameworkCallback
{
public:
    bqFrameworkCallback() {}
    virtual ~bqFrameworkCallback() {}

    virtual void OnMessage() = 0;
};

// API для фреймворка.
class bqFramework
{
public:
    static void Start(bqFrameworkCallback*);
    static void Stop();
    static void Update();

    static float* GetDeltaTime();
    static bqWindow* SummonWindow(bqWindowCallback*);
};

class bqFrameworkImpl
{
public:
    bqFrameworkImpl() {}
    ~bqFrameworkImpl() {}

    float m_deltaTime = 0.f;
    bqFrameworkCallback* m_frameworkCallback = 0;
    
    BQ_PLACEMENT_ALLOCATOR(bqFrameworkImpl);
};

bqFrameworkImpl* g_framework = 0;

// Выделяю память
void bqFramework::Start(bqFrameworkCallback* cb)
{
    BQ_ASSERT_ST(cb);
    BQ_ASSERT_ST(!g_framework);
    if (!g_framework)
    {
  g_framework = new bqFrameworkImpl();
    }
}

// Освобождаю
void bqFramework::Stop()
{
    BQ_ASSERT_ST(g_framework);
    if (g_framework)
    {
  delete g_framework;
  g_framework = 0;
    }
}

void bqFramework::Update()
{
    BQ_ASSERT_ST(g_framework);
}

float* bqFramework::GetDeltaTime()
{
    BQ_ASSERT_ST(g_framework);
    return &g_framework->m_deltaTime;
}

bqWindow* bqFramework::SummonWindow(bqWindowCallback* cb)
{
    BQ_ASSERT_ST(g_framework);
    BQ_ASSERT_ST(cb);
    return 0;
}

class bqFrameworkDestroyer
{
public:
    bqFrameworkDestroyer() {}
    ~bqFrameworkDestroyer()
    {
  if (g_framework)
   bqFramework::Stop();
    }
};
// При закрытии программы этот объект будет уничтожен - будет вызван деструктор
//   в котором будет вызван bqFramework::Stop();
bqFrameworkDestroyer g_frameworkDestroyer;