编程与调试 -- Tiny Source Code, Tiny My Life

setlocale(LC_ALL, "chs");
#include <atlbase.h>
#include <atlconv.h>
#include <atlstr.h>
USES_CONVERSION_EX;
CW2A(L"中文字符", CP_UTF8);

s.String::~String();     // non-virtual call
ps->String::~String();   // non-virtual call

s.~String();       // Virtual call
ps->~String();     // Virtual call

#include <filesystem>

std::string file_name = "deadman";
if (std::filesystem::exists(file_name)) {
    if (std::filesystem::is_directory(file)) {
        printf("%s is a directory\n", file_name.c_str());
    } else if (std::filesystem::is_regular_file(file)) {
        printf("%s is a file\n", file_name.c_str());
    } else {
        printf("%s exists\n", file_name.c_str());
    }
} else {
    printf("%s does not exist\n", file_name.c_str());
}

#include <sys/types.h>
#include <sys/stat.h>

std::string file_name = "deadman";
struct stat info;
if (stat(file_name.c_str(), &info) != 0) {  // does not exist
    printf("cannot access %s\n", file_name.c_str());
} else if (info.st_mode & S_IFDIR) {        // directory
    printf("%s is a directory\n", file_name.c_str());
} else {
    printf("%s is no directory\n", file_name.c_str());
}

struct S3 {
    double d;
    char c;
    int i;
};
struct S4 {
    char c1;
    struct S3 s3;
    double d;
};
    int tempk = sizeof(struct S4); // 32
    tempk = sizeof(struct S3); // 16
    tempk = 0;

#include <iostream>

struct MyStruct {
    int a = 10;
    int b = 20;
    int c = 30;
    int d = 40;
};

// 1. 栈的生长方向
void test01() {
    int a = 10;
    int b = 20;
    int c = 30;
    int d = 40;
    MyStruct st;

    // a 的地址大于 b 的地址，故而生长方向向下。
    printf("a = %d\n", &a); // a = 5240956
    printf("b = %d\n", &b); // b = 5240944
    printf("c = %d\n", &c); // c = 5240932
    printf("d = %d\n", &d); // d = 5240920
    printf("a = %d\n", &st.a); // a = 5240896
    printf("b = %d\n", &st.b); // b = 5240900
    printf("c = %d\n", &st.c); // c = 5240904
    printf("d = %d\n", &st.d); // d = 5240908
}

// 2. 内存生长方向（小端模式）
void test02() {

    // 高位字节 -> 地位字节
    int num = 0xaabbccdd;
    unsigned char* p = (unsigned char*)&num;

    // 从首地址开始的第一个字节
    printf("%x\n", *p); // dd
    printf("%x\n", *(p + 1)); // cc
    printf("%x\n", *(p + 2)); // bb
    printf("%x\n", *(p + 3)); // aa
}

int main()
{
    test01();
    test02();
    return 0;
}

/* ideally we should check whether for the linker language of the target
    CMAKE_${LANG}_CREATE_SHARED_LIBRARY is defined and if not default to
    STATIC. But at this point we know only the name of the target, but not
    yet its linker language. */
if ((type == cmStateEnums::SHARED_LIBRARY ||
        type == cmStateEnums::MODULE_LIBRARY) &&
        !mf.GetState()->GetGlobalPropertyAsBool("TARGET_SUPPORTS_SHARED_LIBS")) {
    mf.IssueMessage(
        MessageType::AUTHOR_WARNING,
        cmStrCat(
            "ADD_LIBRARY called with ",
            (type == cmStateEnums::SHARED_LIBRARY ? "SHARED" : "MODULE"),
            " option but the target platform does not support dynamic linking. ",
            "Building a STATIC library instead. This may lead to problems."));
    type = cmStateEnums::STATIC_LIBRARY;
}

int cvtype = CV_8UC1; // 0
cvtype = CV_8UC2; // 8
cvtype = CV_8UC3; // 16
cvtype = CV_32FC1; // 5
cvtype = CV_32FC3; // 21

// std::vector Debug 版本第一位是：`_Myproxy` 。
#if _ITERATOR_DEBUG_LEVEL != 0
#define MatVecFirst(x) (  (cv::Mat*)  ((size_t*)&(x))[1]  )
#define MatVecLast(x)  (  (cv::Mat*)  ((size_t*)&(x))[2]  )
#define MatVecEnd(x)   (  (cv::Mat*)  ((size_t*)&(x))[3]  )
#else
#define MatVecFirst(x) (  (cv::Mat*)  ((size_t*)&(x))[0]  )
#define MatVecLast(x)  (  (cv::Mat*)  ((size_t*)&(x))[1]  )
#define MatVecEnd(x)   (  (cv::Mat*)  ((size_t*)&(x))[2]  )
#endif
#define MatVecLen(x)   ((char*)MatVecLast(x) - (char*)MatVecFirst(x))
#define MatVecCount(x) ((unsigned int)(-1227133513 * (MatVecLen(x) >> 3)))

#if _ITERATOR_DEBUG_LEVEL != 0
#define UMatVecFirst(x) (  (cv::UMat*)  ((size_t*)&(x))[1]  )
#define UMatVecLast(x)  (  (cv::UMat*)  ((size_t*)&(x))[2]  )
#define UMatVecEnd(x)   (  (cv::UMat*)  ((size_t*)&(x))[3]  )
#else
#define UMatVecFirst(x) (  (cv::UMat*)  ((size_t*)&(x))[0]  )
#define UMatVecLast(x)  (  (cv::UMat*)  ((size_t*)&(x))[1]  )
#define UMatVecEnd(x)   (  (cv::UMat*)  ((size_t*)&(x))[2]  )
#endif
#define UMatVecLen(x)   ((char*)UMatVecLast(x) - (char*)UMatVecFirst(x))
#define UMatVecCount(x) ((unsigned int)(-1431655765 * (UMatVecLen(x) >> 2)))

#include <iostream>
#include <assert.h>

static unsigned int zinvArray[] = {
    0x00000001,	/*  1 */  0x00000001,	/*  2 */
    0xaaaaaaab,	/*  3 */  0x00000001,	/*  4 */
    0xcccccccd,	/*  5 */  0xaaaaaaab,	/*  6 */
    0xb6db6db7,	/*  7 */  0x00000001,	/*  8 */
    0x38e38e39,	/*  9 */  0xcccccccd,	/* 10 */
    0xba2e8ba3,	/* 11 */  0xaaaaaaab,	/* 12 */
    0xc4ec4ec5,	/* 13 */  0xb6db6db7,	/* 14 */
    0xeeeeeeef,	/* 15 */  0x00000001,	/* 16 */
    0xf0f0f0f1,	/* 17 */  0x38e38e39,	/* 18 */
    0x286bca1b,	/* 19 */  0xcccccccd,	/* 20 */
    0x3cf3cf3d,	/* 21 */  0xba2e8ba3,	/* 22 */
    0xe9bd37a7,	/* 23 */  0xaaaaaaab,	/* 24 */
    0xc28f5c29,	/* 25 */  0xc4ec4ec5,	/* 26 */
    0x684bda13,	/* 27 */  0xb6db6db7,	/* 28 */
    0x4f72c235,	/* 29 */  0xeeeeeeef,	/* 30 */
    0xbdef7bdf,	/* 31 */  0x00000001	/* 32 */
};

static unsigned char ctzArray[] =
{ 0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5 };

void check(int num, int zinv, int ctz) {
    if (num <= 32) {
        printf("**[%d] %x,%d / ref %x,%d \n",
            num, zinv, ctz, zinvArray[num - 1], ctzArray[num - 1]);
        assert(zinv == zinvArray[num - 1]);
        assert(ctz == ctzArray[num - 1]);
    }
    for (int i = 0; i < 1000; i++) {
        if (i % num != 0) continue;
        auto value1 = i / num;
        auto value2 = zinv * (i >> ctz);
        // printf("%d,%d,%d,%d -- %d %d \n", i, num, zinv, ctz, value1, value2);
        assert(value1 == value2);
    }
}

/* INV_TABLE[i] holds the multiplicative inverse of (2*i+1) mod 2**32. */
static const unsigned int INV_TABLE[128] = {
    0x00000001, 0xAAAAAAAB, 0xCCCCCCCD, 0xB6DB6DB7,
    0x38E38E39, 0xBA2E8BA3, 0xC4EC4EC5, 0xEEEEEEEF,
    0xF0F0F0F1, 0x286BCA1B, 0x3CF3CF3D, 0xE9BD37A7,
    0xC28F5C29, 0x684BDA13, 0x4F72C235, 0xBDEF7BDF,
    0x3E0F83E1, 0x8AF8AF8B, 0x914C1BAD, 0x96F96F97,
    0xC18F9C19, 0x2FA0BE83, 0xA4FA4FA5, 0x677D46CF,
    0x1A1F58D1, 0xFAFAFAFB, 0x8C13521D, 0x586FB587,
    0xB823EE09, 0xA08AD8F3, 0xC10C9715, 0xBEFBEFBF,
    0xC0FC0FC1, 0x07A44C6B, 0xA33F128D, 0xE327A977,
    0xC7E3F1F9, 0x962FC963, 0x3F2B3885, 0x613716AF,
    0x781948B1, 0x2B2E43DB, 0xFCFCFCFD, 0x6FD0EB67,
    0xFA3F47E9, 0xD2FD2FD3, 0x3F4FD3F5, 0xD4E25B9F,
    0x5F02A3A1, 0xBF5A814B, 0x7C32B16D, 0xD3431B57,
    0xD8FD8FD9, 0x8D28AC43, 0xDA6C0965, 0xDB195E8F,
    0x0FDBC091, 0x61F2A4BB, 0xDCFDCFDD, 0x46FDD947,
    0x56BE69C9, 0xEB2FDEB3, 0x26E978D5, 0xEFDFBF7F,
    0x0FE03F81, 0xC9484E2B, 0xE133F84D, 0xE1A8C537,
    0x077975B9, 0x70586723, 0xCD29C245, 0xFAA11E6F,
    0x0FE3C071, 0x08B51D9B, 0x8CE2CABD, 0xBF937F27,
    0xA8FE53A9, 0x592FE593, 0x2C0685B5, 0x2EB11B5F,
    0xFCD1E361, 0x451AB30B, 0x72CFE72D, 0xDB35A717,
    0xFB74A399, 0xE80BFA03, 0x0D516325, 0x1BCB564F,
    0xE02E4851, 0xD962AE7B, 0x10F8ED9D, 0x95AEDD07,
    0xE9DC0589, 0xA18A4473, 0xEA53FA95, 0xEE936F3F,
    0x90948F41, 0xEAFEAFEB, 0x3D137E0D, 0xEF46C0F7,
    0x028C1979, 0x791064E3, 0xC04FEC05, 0xE115062F,
    0x32385831, 0x6E68575B, 0xA10D387D, 0x6FECF2E7,
    0x3FB47F69, 0xED4BFB53, 0x74FED775, 0xDB43BB1F,
    0x87654321, 0x9BA144CB, 0x478BBCED, 0xBFB912D7,
    0x1FDCD759, 0x14B2A7C3, 0xCB125CE5, 0x437B2E0F,
    0x10FEF011, 0xD2B3183B, 0x386CAB5D, 0xEF6AC0C7,
    0x0E64C149, 0x9A020A33, 0xE6B41C55, 0xFEFEFEFF
};

int main()
{
    int count = sizeof(zinvArray) / sizeof(zinvArray[0]);
    int count2 = sizeof(ctzArray) / sizeof(ctzArray[0]);
    assert(count == count2);
    for (int i = 0; i < count; i++) {
        check(i + 1, zinvArray[i], ctzArray[i]);
    }

    int countx = sizeof(INV_TABLE) / sizeof(INV_TABLE[0]);
    for (int num = 1; num <= 2000; num++) {
        if (num % 2 == 0) {
            int shift = 0;
            int temp = num;
            while (temp && (temp % 2 == 0)) {
                shift++;
                temp = temp >> 1;
            }
            int index = (temp - 1) / 2;
            if (index >= countx) continue;
            printf("num=%d idx=%d inv=%x shift=%d \n",
                num, index, INV_TABLE[index], shift);
            check(num, INV_TABLE[index], shift);
        } else {
            int index = (num - 1) / 2;
            if (index >= countx) continue;
            printf("num=%d idx=%d inv=%x shift=%d \n",
                num, index, INV_TABLE[index], 0);
            check(num, INV_TABLE[index], 0);
        }
    }

    getchar();
    return 0;
}

#include <iostream>

int checkdiv(int num, int div, bool output=false, int shdiv=1) {
    bool retv = true;
    for (int i = 0; i < 9100; i++) {
        if (i % div) continue;
        if (output && (i < 100 || i >= 9000)) {
            printf("[%d]%s [0x%x/%d,%d] %d -- %d \n", //
                i, retv ? "True" : "False", //
                num, shdiv, div, i * num / shdiv, i / div);
        }
        if (i * num / shdiv != i / div) {
            retv = false;
        }
    }
    return retv;
}
int checkdiv(int num) {
    for (int x = 2; x <= 200; x++) {
        if (checkdiv(num, x)) {
            return x;
        }
    }
    return 0;
}
void printdiv(int num, int div) {
    printf("printdiv %d %d \n", num, div);
}

int main()
{
    int ksize = klistsize;
    // 1431655766?
    int div = 0;
    if (div = checkdiv(1431655766)) {
        printdiv(1431655766, div);
    }
    checkdiv(1431655766, 3, true, 2);
    for (int i = 0; i < ksize; i++) {
        if (div = checkdiv(klist[i])) {
            printdiv(klist[i], div);
        }
    }

    getchar();
    return 0;
}

#define CASE_RETURN(x) case x: return L ## #x

inline std::string GetKernelCode(const std::string & filename)
{
    std::stringstream buffer;
    buffer << std::ifstream(filename.c_str()).rdbuf();
    return buffer.str();
}

if (!PathFileExists(fpath)) {
    CreateDirectory(fpath, NULL);
}

wchar_t fpath[MAX_PATH + 1] = { 0 };
DWORD res = GetTempPath(MAX_PATH, fpath);
if (res <= 0 || res >= MAX_PATH) {
    return gpuip::GPUIP_CODE::CODE_ERROR;
}

// 加载 dll 不要弹框报错。
auto modex = SEM_FAILCRITICALERRORS |     //
             SEM_NOALIGNMENTFAULTEXCEPT | //
             SEM_NOGPFAULTERRORBOX |      //
             SEM_NOOPENFILEERRORBOX;
auto modebak = ::SetErrorMode(modex);

HINSTANCE hDLL = LoadLibrary(current.c_str());

auto modey = ::SetErrorMode(modebak);
assert(modey == modex);

/**
4294967293 fffffffd -- -3 fffffffd
4294967294 fffffffe -- -2 fffffffe
4294967295 ffffffff -- -1 ffffffff
0 0 -- 0 0
1 1 -- 1 1
2 2 -- 2 2
3 3 -- 3 3*/
    for (int i = -3; i <= 3; i++) {
        unsigned int ui = (unsigned int) i;
        printf("%u %x -- %d %x \n", i, i, ui, ui);
    }

// 64 位版本：
int a = sizeof(int); // 4
a = sizeof(long); // 4
a = sizeof(long long); // 8
a = sizeof(__int64); // 8
a = sizeof(void*); // 8
a = 0;

enum ColorConversionCodes {
    COLOR_BGR2BGRA     = 0, //!< add alpha channel to RGB or BGR image
    COLOR_RGB2RGBA     = COLOR_BGR2BGRA,

    COLOR_BGRA2BGR     = 1, //!< remove alpha channel from RGB or BGR image
    COLOR_RGBA2RGB     = COLOR_BGRA2BGR,

    COLOR_BGR2RGBA     = 2, //!< convert between RGB and BGR color spaces (with or without alpha channel)
    COLOR_RGB2BGRA     = COLOR_BGR2RGBA,

    COLOR_RGBA2BGR     = 3,
    COLOR_BGRA2RGB     = COLOR_RGBA2BGR,

    COLOR_BGR2RGB      = 4,
    COLOR_RGB2BGR      = COLOR_BGR2RGB,

    COLOR_BGRA2RGBA    = 5,
    COLOR_RGBA2BGRA    = COLOR_BGRA2RGBA,

    COLOR_BGR2GRAY     = 6, //!< convert between RGB/BGR and grayscale, @ref color_convert_rgb_gray "color conversions"
    COLOR_RGB2GRAY     = 7,
    COLOR_BGRA2GRAY    = 10,
    COLOR_RGBA2GRAY    = 11,

    COLOR_BGR2HSV      = 40, //!< convert RGB/BGR to HSV (hue saturation value), @ref color_convert_rgb_hsv "color conversions"
    COLOR_RGB2HSV      = 41,
};

inline
Mat::~Mat()
{
    release();
    if ( step.p != step.buf )
        fastFree(step.p);
}

inline
void Mat::release()
{
    if ( u && CV_XADD(&u->refcount, -1) == 1 )
        deallocate();
    u = NULL;
    datastart = dataend = datalimit = data = 0;
    for (int i = 0; i < dims; i++)
        size.p[i] = 0;
}

// 生成汇编
if ( v83.u ) {
    v32 = &v83.u->refcount;
    v33 = GetAndSub((unsigned int *)v32);
    if ( v33 == 1 )
        CvMatDeallocate(&v83);
}
v83.u = 0;
v34 = (int *)v83.dims;
memset(&v83.data, 0, 16); // datastart = dataend = datalimit = data = 0;
if ( v83.dims >= 1 ) {
    v34 = v83.size.p;
    v35 = 0;
    do {
      v34[v35++] = 0;
      v31 = v83.dims;
    }
    while ( v35 < v83.dims );
}
if ( v83.step.p != v83.step.buf )
    CvFastFree((mycv *)v83.step.p, v34);

inline
Mat& Mat::operator = (Mat&& m)
{
    if (this == &m)
      return *this;

    release();
    flags = m.flags; dims = m.dims; rows = m.rows; cols = m.cols; data = m.data;
    datastart = m.datastart; dataend = m.dataend; datalimit = m.datalimit; allocator = m.allocator;
    u = m.u;
    if (step.p != step.buf) { // release self step/size
        fastFree(step.p);
        step.p = step.buf;
        size.p = &rows;
    }
    if (m.dims <= 2) { // move new step/size info
        step[0] = m.step[0];
        step[1] = m.step[1];
    } else {
        CV_DbgAssert(m.step.p != m.step.buf);
        step.p = m.step.p;
        size.p = m.size.p;
        m.step.p = m.step.buf;
        m.size.p = &m.rows;
    }
    m.flags = MAGIC_VAL; m.dims = m.rows = m.cols = 0;
    m.data = NULL; m.datastart = NULL; m.dataend = NULL; m.datalimit = NULL;
    m.allocator = NULL;
    m.u = NULL;
    return *this;
}

inline
Mat& Mat::operator = (const Mat& m)
{
    if ( this != &m ) {
        if ( m.u )
            CV_XADD(&m.u->refcount, 1);
        release();
        flags = m.flags;
        if ( dims <= 2 && m.dims <= 2 ) {
            dims = m.dims;
            rows = m.rows;
            cols = m.cols;
            step[0] = m.step[0];
            step[1] = m.step[1];
        } else
            copySize(m);
        data = m.data;
        datastart = m.datastart;
        dataend = m.dataend;
        datalimit = m.datalimit;
        allocator = m.allocator;
        u = m.u;
    }
    return *this;
}

inline
Mat::Mat(const Mat& m)
    : flags(m.flags), dims(m.dims), rows(m.rows), cols(m.cols), data(m.data),
      datastart(m.datastart), dataend(m.dataend), datalimit(m.datalimit), allocator(m.allocator),
      u(m.u), size(&rows), step(0)
{
    if ( u )
        CV_XADD(&u->refcount, 1);
    if ( m.dims <= 2 ) {
        step[0] = m.step[0]; step[1] = m.step[1];
    } else {
        dims = 0;
        copySize(m);
    }
}

inline Mat& Mat::operator=(const Mat& m)
{
    if (this == &m)
        return *this;

    if (m.refcount)
        NCNN_XADD(m.refcount, 1);

    release();

    data = m.data;
    refcount = m.refcount;
    elemsize = m.elemsize;
    elempack = m.elempack;
    allocator = m.allocator;

    dims = m.dims;
    w = m.w;
    h = m.h;
    c = m.c;

    cstep = m.cstep;

    return *this;
}

inline void Mat::release()
{
    if (refcount && NCNN_XADD(refcount, -1) == 1) {
        if (allocator)
            allocator->fastFree(data);
        else
            fastFree(data);
    }

    data = 0;

    elemsize = 0;
    elempack = 0;

    dims = 0;
    w = 0;
    h = 0;
    c = 0;

    cstep = 0;

    refcount = 0;
}

inline
Mat Mat::clone() const
{
    Mat m;
    copyTo(m);
    return m;
}

#include <iostream>
#include <Windows.h>
#include <assert.h>
#include <opencv2/opencv.hpp>
#include <stdio.h>
#include <process.h>
#include <io.h>
#include <direct.h>
#include <vld.h>
#include "../testwin.h"

#include <Shlwapi.h>
#pragma comment(lib, "shlwapi.lib") // Windows API PathFileExists
#include "../../dcode/enhancedef.h"

#include <ncnn/mat.h>
#include <ncnn/allocator.h>
#include <ncnn/cpu.h>
#include <ncnn/net.h>

enum {
    KIND_SHIFT = 16,
    FIXED_TYPE = 0x8000 << KIND_SHIFT,
    FIXED_SIZE = 0x4000 << KIND_SHIFT,
    KIND_MASK = 31 << KIND_SHIFT,

    NONE = 0 << KIND_SHIFT,
    MAT = 1 << KIND_SHIFT,
    MATX = 2 << KIND_SHIFT,
    STD_VECTOR = 3 << KIND_SHIFT,
    STD_VECTOR_VECTOR = 4 << KIND_SHIFT,
    STD_VECTOR_MAT = 5 << KIND_SHIFT,
    EXPR = 6 << KIND_SHIFT,
    OPENGL_BUFFER = 7 << KIND_SHIFT,
    CUDA_HOST_MEM = 8 << KIND_SHIFT,
    CUDA_GPU_MAT = 9 << KIND_SHIFT,
    UMAT = 10 << KIND_SHIFT,
    STD_VECTOR_UMAT = 11 << KIND_SHIFT,
    STD_BOOL_VECTOR = 12 << KIND_SHIFT,
    STD_VECTOR_CUDA_GPU_MAT = 13 << KIND_SHIFT,
    STD_ARRAY = 14 << KIND_SHIFT,
    STD_ARRAY_MAT = 15 << KIND_SHIFT
};

enum {
    ACCESS_READ = 1 << 24, ACCESS_WRITE = 1 << 25,
    ACCESS_RW = 3 << 24, ACCESS_FAST = 1 << 26
};

enum
{
    DEPTH_MASK_8U = 1 << CV_8U,
    DEPTH_MASK_8S = 1 << CV_8S,
    DEPTH_MASK_16U = 1 << CV_16U,
    DEPTH_MASK_16S = 1 << CV_16S,
    DEPTH_MASK_32S = 1 << CV_32S,
    DEPTH_MASK_32F = 1 << CV_32F,
    DEPTH_MASK_64F = 1 << CV_64F,
    DEPTH_MASK_ALL = (DEPTH_MASK_64F << 1) - 1,
    DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
    DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
};

#define PARSE_CHECK(mat) if (knum & mat) { \
unsigned int znum = knum & (~mat); \
if (!code) { \
printf("parse - cv::" #mat " %08x %08x/%08x \n", mat, knum, znum); } \
knum = znum; strcat(buffer, "+cv::" #mat); check += mat; \
} assert(getBinCount(mat) == 1);

#define PARSE_CHECK_KIND(mat) if ((knum & (KIND_MASK)) == mat) { \
unsigned int znum = knum & (~(KIND_MASK)); \
if (!code) { \
printf("parse - cv::" #mat " %08x %08x/%08x \n", mat, knum, znum); } \
knum = znum; strcat(buffer, "+cv::" #mat); check += mat; \
}

int getBinCount(const unsigned int src) {
    int count = 0;
    unsigned int knum = src;
    while (knum) {
        if (knum & 1) {
            count++;
        }
        knum = knum >> 1;
    }
    if (count != 1) {
        assert(count == 1);
    }
    return count;
}

//#include "E:\kSource\blog\invisible\decompile\mycv.h"
int parseCvMagic(unsigned int knum, bool code = false) {
    if (!code) {
        printf("---------- \n");
    }
    const unsigned int src = knum;
    unsigned int check = 0; // 累加上去。
    char buffer[1024] = { 0 };

    enum { MAGIC_VAL = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG };
    enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 };

    unsigned int cont = CV_MAT_CONT_FLAG;
    unsigned int submat = CV_SUBMAT_FLAG;
    PARSE_CHECK(CV_MAT_CONT_FLAG);
    PARSE_CHECK(CV_SUBMAT_FLAG);
    CV_UNUSED(cont);
    CV_UNUSED(submat);

    PARSE_CHECK(ACCESS_READ);
    PARSE_CHECK(ACCESS_WRITE);
    //PARSE_CHECK(ACCESS_RW);
    PARSE_CHECK(ACCESS_FAST);

    PARSE_CHECK_KIND(MAT);
    PARSE_CHECK_KIND(MATX);
    PARSE_CHECK_KIND(STD_VECTOR);
    PARSE_CHECK_KIND(STD_VECTOR_VECTOR);
    PARSE_CHECK_KIND(STD_VECTOR_MAT);
    PARSE_CHECK_KIND(EXPR);
    PARSE_CHECK_KIND(OPENGL_BUFFER);
    PARSE_CHECK_KIND(CUDA_HOST_MEM);
    PARSE_CHECK_KIND(CUDA_GPU_MAT);
    PARSE_CHECK_KIND(UMAT);
    PARSE_CHECK_KIND(STD_VECTOR_UMAT);
    PARSE_CHECK_KIND(STD_BOOL_VECTOR);
    PARSE_CHECK_KIND(STD_VECTOR_CUDA_GPU_MAT);
    PARSE_CHECK_KIND(STD_ARRAY);
    PARSE_CHECK_KIND(STD_ARRAY_MAT);

    PARSE_CHECK(FIXED_TYPE);
    PARSE_CHECK(FIXED_SIZE);

    PARSE_CHECK(DEPTH_MASK_8U);
    PARSE_CHECK(DEPTH_MASK_8S);
    PARSE_CHECK(DEPTH_MASK_16U);
    PARSE_CHECK(DEPTH_MASK_16S);
    PARSE_CHECK(DEPTH_MASK_32S);
    PARSE_CHECK(DEPTH_MASK_32F);
    PARSE_CHECK(DEPTH_MASK_64F);
    //PARSE_CHECK(DEPTH_MASK_ALL);
    //PARSE_CHECK(DEPTH_MASK_ALL_BUT_8S);
    //PARSE_CHECK(DEPTH_MASK_FLT);

    unsigned int xtype = knum & TYPE_MASK;
    if (xtype) {
        assert(xtype == 0);
    }

    unsigned int magic = knum & MAGIC_MASK;
    if (magic) {
        assert(magic == 0);
    }

    unsigned int depth = knum & DEPTH_MASK;
    if (depth) {
        assert(depth == 0);
    }

    if (knum == 0) { // 用完了。
        printf("%d | 0x%x | (%s) \n", src, src, &buffer[1]);
    } else { // 有剩余 !!!
        printf("%d | 0x%x | (%s | 0x%x) \n", src, src, &buffer[1], knum);
    }
    if (check != src || knum != 0) {
        assert(check + knum == src);
        assert(check == src);
        assert(knum == 0);
    }
    return knum;
}

void testmagic() {

    int k = 0;
    k = sizeof(cv::Size); // 8
    k = sizeof(std::vector<int>); // 16
    k = sizeof(cv::Mat); // 56
    k = sizeof(std::initializer_list<int>); // 8
    k = sizeof(std::array<int, 2>); // 8
    k = sizeof(cv::Vec<int, 2>); // 8
    k = sizeof(cv::Matx<int, 2, 3>); // 24
    k = sizeof(cv::Point_<int>); // 8
    k = sizeof(cv::Point3_<int>); // 12
    k = sizeof(cv::MatCommaInitializer_<int>); // 20

    cv::Vec4d vec;
    cv::InputArray array(vec);
    k = array.getFlags();
    parseCvMagic(k, true);

    parseCvMagic(33619968, true);
    parseCvMagic(16842752, true);
    parseCvMagic(33882112, true);
    parseCvMagic(17104896, true);

    parseCvMagic(-2130509812, true);
    parseCvMagic(-1040056315, true);
    parseCvMagic(-1056833530, true);

    // 这几个存在疑问。
    parseCvMagic(1072693248, true);
    parseCvMagic(1074266112, true);
    parseCvMagic(1081073664, true);
    parseCvMagic(1079623680, true);
}

int main(int argc, char *argv[])
{
    testmagic();

    printf("ok");
    getchar();
    return 0;
}

if (outx == 0) {
    auto xxd = v25 * 255.0;
    float xxdf = (float)xxd;
    int t1 = (int)xxdf;
    int t2 = (unsigned int)xxdf; // 这里 32 系统，64 系统不一样。
    printf("v25 = %f \n", v25);
    printf("v25 = %f \n", xxd);
    printf("v25 = %f %x  %x:%x \n", xxdf, *(_DWORD*)&xxdf, t1, t2);
    printf("v25 = %x %d \n", (unsigned int)xxdf, temp);
}

for (int i = 0; i < 10; i++) {
    int a = i * 5;
    int b = a * 3435973837;
    printf("%u %u \n", a, b);
    assert(a / 5 == b);
}

static <type> guard;

if (!guard.first_byte) {
    if (__cxa_guard_acquire (&guard)) {
        bool flag = false;

        try {
            // Do initialization.
            __cxa_guard_release (&guard);

            flag = true;
            // Register variable for destruction at end of program.
        } catch {
            if (!flag) {
                __cxa_guard_abort (&guard);
            }
        }
    }
}

delete []objects; // 正确的用法
delete objects;   // 错误的用法

wchar_t* pstr = nullptr;
CString exe = pstr; // 不会崩溃。
exe.Append(L"test");

// 0xC0000005: 读取位置 0x00000000 时发生访问冲突。
std::wstring tempexe = pstr; // 会崩溃。
tempexe.append(L"test");

bool endsWith(const CString& str, const CString& suffix, bool ignoreCase)
{
    int totalSize = str.GetLength();
    int suffixSize = suffix.GetLength();
    if (totalSize < suffixSize) {
        return false;
    }
    if (ignoreCase) {
        return str.Right(suffixSize).CompareNoCase(suffix) == 0;
    }
    return str.Right(suffixSize).Compare(suffix) == 0;
}

__int64 winMemoCtrl() {
    MEMORYSTATUSEX memory_status;
    memory_status.dwLength = sizeof(memory_status);
    GlobalMemoryStatusEx(&memory_status);

    if (memory_status.ullAvailPhys <= 500 * 1024 * 1024) {
        return 30 * 1024 * 1024;
    }

    return 100 * 1024 * 1024;
}

int* datap = (int*) data;
unsigned char* check = (unsigned char*) data;
// 0xFF4080C0
if (check[3] >= 0xf0 && //
    0xf0 > check[0] &&
    check[0] > check[1] && //
    check[1] > check[2]) {

    datap[0] = color;
    cv::cvtColor(src, tempmat, cv::COLOR_RGBA2RGB);

    // 0xFFC08040
} else if (check[3] >= 0xf0 && //
           0xf0 > check[2] &&
           check[2] > check[1] && //
           check[1] > check[0]) {

    // RGBA -> BGRA
    char* p = (char*)&color;
    char r = *(p+0);
    char b = *(p+2);
    *(p+0) = b;
    *(p+2) = r;
    datap[0] = color;
    cv::cvtColor(src, tempmat, cv::COLOR_BGRA2RGB);

    // 0xffa8bbc2 - 0xff??
} else {
#if defined(_DEBUG) || defined(DEBUG)
    throw std::invalid_argument("img data err");  // checked(8Ia6)
#else
    return -1;
#endif
}

char buffer[1024];
sprintf(buffer, "char | %d \n", sizeof(char));
sprintf(buffer, "short | %d \n", sizeof(short));
sprintf(buffer, "int | %d \n", sizeof(int));
sprintf(buffer, "long | %d \n", sizeof(long));
sprintf(buffer, "long long | %d \n", sizeof(long long));
sprintf(buffer, "__int64 | %d \n", sizeof(__int64));
sprintf(buffer, "float | %d \n", sizeof(float));
sprintf(buffer, "double | %d \n", sizeof(double));
sprintf(buffer, "long double | %d \n", sizeof(long double));
sprintf(buffer, "void* | %d \n", sizeof(void*));
sprintf(buffer, "size_t | %d \n", sizeof(size_t));

#include <windows.h>
#include <iostream>

if (OpenClipboard())
{
    HGLOBAL hGBClipboard;
    char *chBufferText;
    EmptyClipboard();
    hGBClipboard = GlobalAlloc(GMEM_DDESHARE, strClipboardText.GetLength() + 1);
    chBufferText = (char*)GlobalLock(hGBClipboard);
    strcpy(chBufferText, LPCSTR(strClipboardText));
    GlobalUnlock(hGBClipboard);
    SetClipboardData(CF_TEXT, hGBClipboard);
    CloseClipboard();
}

if (OpenClipboard())
{
    HANDLE hClipboardData = GetClipboardData(CF_TEXT);
    char *chBufferText = (char*)GlobalLock(hClipboardData);
    strClipboardText = chBufferText;
    GlobalUnlock(hClipboardData);
    CloseClipboard();
}

#include <assert.h>
#include <Windows.h>
#include <TlHelp32.h>
BOOL GetCurrentMainThreadID(DWORD* pdwThreadID)
{
    HANDLE hThreadSnap = INVALID_HANDLE_VALUE;
    BOOL bRet = FALSE;
    THREADENTRY32 te32 = {0};
    DWORD dwProcessId = 0;
    static DWORD Curl_dwMainThreadId = 0;

    if (!pdwThreadID) {
        return FALSE;
    }
    if (Curl_dwMainThreadId) {
        *pdwThreadID = Curl_dwMainThreadId;
        return TRUE;
    }

    dwProcessId = GetCurrentProcessId();
    //  Take a snapshot of all processes in the system.
    hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
    if (hThreadSnap == INVALID_HANDLE_VALUE) {
        return FALSE;
    }

    //  Fill in the size of the structure before using it.
    te32.dwSize = sizeof(THREADENTRY32);
    if (Thread32First(hThreadSnap, &te32)) {
        if (te32.th32OwnerProcessID == dwProcessId) {
            *pdwThreadID = te32.th32ThreadID;
            Curl_dwMainThreadId = te32.th32ThreadID;
            bRet = TRUE;
        }
    }
    while (!bRet && Thread32Next(hThreadSnap, &te32)) {
        if (te32.th32OwnerProcessID == dwProcessId) {
            *pdwThreadID = te32.th32ThreadID;
            Curl_dwMainThreadId = te32.th32ThreadID;
            bRet = TRUE;
        }
    }

    // Do not forget to clean up the snapshot object.
    CloseHandle (hThreadSnap);
    return bRet;
}

void CheckAssertMainThread() {
#if _DEBUG
    DWORD dwThreadID = 0;
    if (GetCurrentMainThreadID(&dwThreadID)) {
        assert(dwThreadID != GetCurrentThreadId());
    }
#endif
}

#pragma once

#ifndef __TOY_SINGLEINSTANCE_H__
#define __TOY_SINGLEINSTANCE_H__

#include <Windows.h>
#include <atlstr.h>

namespace toy
{
    class ToySingleInstance
    {
    public:
        ToySingleInstance(LPCTSTR strName)
            : m_hMutex(NULL)
            , m_strInstanceName(strName) {
        }

        ~ToySingleInstance()
        {
            Close();
        }

        BOOL IsExist()
        {
            HANDLE hMutex = ::OpenMutex(SYNCHRONIZE, FALSE, m_strInstanceName);
            if (hMutex) {
                ::CloseHandle(hMutex);
                return TRUE;
            }
            return FALSE;
        }

        BOOL Create()
        {
            if (IsExist())
                return FALSE;

            HANDLE hMutex = CreateMutex(
                NULL,
                TRUE,
                m_strInstanceName
            );

            if (hMutex == NULL) {
                return FALSE;
            } else if (GetLastError() == ERROR_ALREADY_EXISTS) {
                ::CloseHandle(hMutex);
                return FALSE;
            }

            m_hMutex = hMutex;
            hMutex = NULL;

            return TRUE;
        }

        VOID Close()
        {
            if (m_hMutex) {
                CloseHandle(m_hMutex);
                m_hMutex = NULL;
            }
        }

    private:
        CString m_strInstanceName;
        HANDLE m_hMutex;
    };
}

#endif