Update about Manager.

priread (never using)/ReadMe.txt

@@ -0,0 +1,30 @@
+========================================================================
+    动态链接库：priread 项目概述
+========================================================================
+
+应用程序向导已为您创建了此 priread DLL。
+
+本文件概要介绍组成 priread 应用程序的每个文件的内容。
+
+
+priread.vcxproj
+    这是使用应用程序向导生成的 VC++ 项目的主项目文件，其中包含生成该文件的 Visual C++ 的版本信息，以及有关使用应用程序向导选择的平台、配置和项目功能的信息。
+
+priread.vcxproj.filters
+    这是使用“应用程序向导”生成的 VC++ 项目筛选器文件。它包含有关项目文件与筛选器之间的关联信息。在 IDE 中，通过这种关联，在特定节点下以分组形式显示具有相似扩展名的文件。例如，“.cpp”文件与“源文件”筛选器关联。
+
+priread.cpp
+    这是主 DLL 源文件。
+
+/////////////////////////////////////////////////////////////////////////////
+其他标准文件:
+
+StdAfx.h, StdAfx.cpp
+    这些文件用于生成名为 priread.pch 的预编译头 (PCH) 文件和名为 StdAfx.obj 的预编译类型文件。
+
+/////////////////////////////////////////////////////////////////////////////
+其他注释:
+
+应用程序向导使用“TODO:”注释来指示应添加或自定义的源代码部分。
+
+/////////////////////////////////////////////////////////////////////////////

priread (never using)/dllmain.cpp

@@ -0,0 +1,19 @@
+// dllmain.cpp : 定义 DLL 应用程序的入口点。
+#include "stdafx.h"
+
+BOOL APIENTRY DllMain( HMODULE hModule,
+                       DWORD  ul_reason_for_call,
+                       LPVOID lpReserved
+					 )
+{
+	switch (ul_reason_for_call)
+	{
+	case DLL_PROCESS_ATTACH:
+	case DLL_THREAD_ATTACH:
+	case DLL_THREAD_DETACH:
+	case DLL_PROCESS_DETACH:
+		break;
+	}
+	return TRUE;
+}
+

priread (never using)/localeex.h

@@ -0,0 +1,163 @@
+#pragma once
+#include <WinNls.h>
+#include <string>
+static std::wstring StringToWString (const std::string &str, UINT codePage = CP_ACP)
+{
+	if (str.empty ()) return std::wstring ();
+	int len = MultiByteToWideChar (codePage, 0, str.c_str (), -1, nullptr, 0);
+	if (len == 0) return std::wstring ();
+	std::wstring wstr (len - 1, L'\0');
+	MultiByteToWideChar (codePage, 0, str.c_str (), -1, &wstr [0], len);
+	return wstr;
+}
+
+#undef GetLocaleInfo
+std::string GetLocaleInfoA (LCID code, LCTYPE type)
+{
+	char buf [LOCALE_NAME_MAX_LENGTH] = {0};
+	GetLocaleInfoA (code, type, buf, LOCALE_NAME_MAX_LENGTH);
+	return buf;
+}
+std::wstring GetLocaleInfoW (LCID code, LCTYPE type)
+{
+	WCHAR buf [LOCALE_NAME_MAX_LENGTH] = {0};
+	GetLocaleInfoW (code, type, buf, LOCALE_NAME_MAX_LENGTH);
+	return buf;
+}
+void GetLocaleInfo (LCID code, LCTYPE type, std::wstring &output)
+{
+	output = GetLocaleInfoW (code, type);
+}
+void GetLocaleInfo (LCID code, LCTYPE type, std::string &output)
+{
+	output = GetLocaleInfoA (code, type);
+}
+int GetLocaleInfoEx (std::wstring lpLocaleName, LCTYPE type, std::wstring &output)
+{
+	WCHAR buf [LOCALE_NAME_MAX_LENGTH] = {0};
+	int res = GetLocaleInfoEx (lpLocaleName.c_str (), type, buf, LOCALE_NAME_MAX_LENGTH);
+	if (&output) output = std::wstring (buf);
+	return res;
+}
+
+#undef SetLocaleInfo
+BOOL SetLocaleInfoA (LCID code, LCTYPE type, const std::string &lcData)
+{
+	return SetLocaleInfoA (code, type, lcData.c_str ());
+}
+BOOL SetLocaleInfoW (LCID code, LCTYPE type, const std::wstring &lcData)
+{
+	return SetLocaleInfoW (code, type, lcData.c_str ());
+}
+BOOL SetLocaleInfo (LCID code, LCTYPE type, const std::wstring &lcData)
+{
+	return SetLocaleInfoW (code, type, lcData);
+}
+BOOL SetLocaleInfo (LCID code, LCTYPE type, const std::string &lcData)
+{
+	return SetLocaleInfoA (code, type, lcData);
+}
+
+std::string GetLocaleRestrictedCodeFromLcidA (LCID lcid)
+{
+	return GetLocaleInfoA (lcid, 89);
+}
+std::wstring GetLocaleRestrictedCodeFromLcidW (LCID lcid)
+{
+	return GetLocaleInfoW (lcid, 89);
+}
+void GetLocaleRestrictedCodeFromLcid (LCID lcid, std::string &ret)
+{
+	ret = GetLocaleRestrictedCodeFromLcidA (lcid);
+}
+void GetLocaleRestrictedCodeFromLcid (LCID lcid, std::wstring &ret)
+{
+	ret = GetLocaleRestrictedCodeFromLcidW (lcid);
+}
+
+std::string GetLocaleElaboratedCodeFromLcidA (LCID lcid)
+{
+	return GetLocaleInfoA (lcid, 90);
+}
+std::wstring GetLocaleElaboratedCodeFromLcidW (LCID lcid)
+{
+	return GetLocaleInfoW (lcid, 90);
+}
+void  GetLocaleElaboratedCodeFromLcid (LCID lcid, std::wstring &ret)
+{
+	ret = GetLocaleElaboratedCodeFromLcidW (lcid);
+}
+void  GetLocaleElaboratedCodeFromLcid (LCID lcid, std::string &ret)
+{
+	ret = GetLocaleElaboratedCodeFromLcidA (lcid);
+}
+
+LCID LocaleCodeToLcidW (LPCWSTR localeCode)
+{
+	BYTE buf [LOCALE_NAME_MAX_LENGTH * sizeof (WCHAR)] = {0};
+	int res = GetLocaleInfoEx (localeCode, LOCALE_RETURN_NUMBER | LOCALE_ILANGUAGE, (LPWSTR)buf, LOCALE_NAME_MAX_LENGTH);
+	LCID lcid = *((LCID *)buf);
+	return lcid;
+}
+LCID LocaleCodeToLcidA (LPCSTR localeCode)
+{
+	std::wstring lcWide = StringToWString (std::string (localeCode));
+	return LocaleCodeToLcidW (lcWide.c_str ());
+}
+LCID LocaleCodeToLcid (const std::wstring &loccode)
+{
+	return LocaleCodeToLcidW (loccode.c_str ());
+}
+LCID LocaleCodeToLcid (const std::string &loccode)
+{
+	return LocaleCodeToLcidA (loccode.c_str ());
+}
+
+std::string GetLocaleRestrictedCodeA (LPCSTR lc)
+{
+	return GetLocaleInfoA (LocaleCodeToLcidA (lc), 89);
+}
+std::string GetLocaleRestrictedCodeA (const std::string &lc)
+{
+	return GetLocaleInfoA (LocaleCodeToLcidA (lc.c_str ()), 89);
+}
+std::wstring GetLocaleRestrictedCodeW (LPCWSTR lc)
+{
+	return GetLocaleInfoW (LocaleCodeToLcidW (lc), 89);
+}
+std::wstring GetLocaleRestrictedCodeW (const std::wstring &lc)
+{
+	return GetLocaleInfoW (LocaleCodeToLcidW (lc.c_str ()), 89);
+}
+std::wstring GetLocaleRestrictedCode (const std::wstring &lc) { return GetLocaleRestrictedCodeW (lc); }
+std::string GetLocaleRestrictedCode (const std::string &lc) { return GetLocaleRestrictedCodeA (lc); }
+
+std::string GetLocaleElaboratedCodeA (LPCSTR lc)
+{
+	return GetLocaleInfoA (LocaleCodeToLcidA (lc), 90);
+}
+std::string GetLocaleElaboratedCodeA (const std::string &lc)
+{
+	return GetLocaleInfoA (LocaleCodeToLcidA (lc.c_str ()), 90);
+}
+std::wstring GetLocaleElaboratedCodeW (LPCWSTR lc)
+{
+	return GetLocaleInfoW (LocaleCodeToLcidW (lc), 90);
+}
+std::wstring GetLocaleElaboratedCodeW (const std::wstring &lc)
+{
+	return GetLocaleInfoW (LocaleCodeToLcidW (lc.c_str ()), 90);
+}
+std::wstring GetLocaleElaboratedCode (const std::wstring &lc) { return GetLocaleElaboratedCodeW (lc); }
+std::string GetLocaleElaboratedCode (const std::string &lc) { return GetLocaleElaboratedCodeA (lc); }
+
+std::string LcidToLocaleCodeA (LCID lcid, char divide = '-')
+{
+	return GetLocaleRestrictedCodeFromLcidA (lcid) + divide + GetLocaleElaboratedCodeFromLcidA (lcid);
+}
+std::wstring LcidToLocaleCodeW (LCID lcid, WCHAR divide = L'-')
+{
+	return GetLocaleRestrictedCodeFromLcidW (lcid) + divide + GetLocaleElaboratedCodeFromLcidW (lcid);
+}
+std::wstring LcidToLocaleCode (LCID lcid, WCHAR divide = L'-') { return LcidToLocaleCodeW (lcid, divide); }
+std::string LcidToLocaleCode (LCID lcid, char divide = '-') { return LcidToLocaleCodeA (lcid, divide); }

priread (never using)/nstring.h

@@ -0,0 +1,456 @@
+#pragma once
+#include <string>
+#include <locale>
+#include <cctype>
+namespace l0km
+{
+	template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>> inline std::basic_string<E, TR, AL> toupper (const std::basic_string <E, TR, AL> &src)
+	{
+		std::basic_string <E, TR, AL> dst = src;
+		static const std::locale loc;
+		const std::ctype <E> &ctype = std::use_facet <std::ctype <E>> (loc);
+		for (typename std::basic_string <E, TR, AL>::size_type i = 0; i < src.size (); ++ i)
+		{
+			dst [i] = ctype.toupper (src [i]);
+		}
+		return dst;
+	}
+	template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>> inline std::basic_string <E, TR, AL> tolower (const std::basic_string <E, TR, AL> &src)
+	{
+		std::basic_string <E, TR, AL> dst = src;
+		static const std::locale loc;
+		const std::ctype <E> &ctype = std::use_facet <std::ctype <E>> (loc);
+		for (typename std::basic_string <E, TR, AL>::size_type i = 0; i < src.size (); ++ i)
+		{
+			dst [i] = ctype.tolower (src [i]);
+		}
+		return dst;
+	}
+	inline char toupper (char ch)
+	{
+		if (ch < -1) return ch;
+		static const std::locale loc;
+		return std::use_facet <std::ctype <char>> (loc).toupper (ch);
+	}
+	inline char tolower (char ch)
+	{
+		if (ch < -1) return ch;
+		static const std::locale loc;
+		return std::use_facet <std::ctype <char>> (loc).tolower (ch);
+	}
+	inline wchar_t toupper (wchar_t ch)
+	{
+		if (ch < -1) return ch;
+		static const std::locale loc;
+		return std::use_facet <std::ctype <wchar_t>> (loc).toupper (ch);
+	}
+	inline wchar_t tolower (wchar_t ch)
+	{
+		if (ch < -1) return ch;
+		static const std::locale loc;
+		return std::use_facet <std::ctype <wchar_t>> (loc).tolower (ch);
+	}
+	inline int toupper (int ch)
+	{
+		if (ch < -1) return ch;
+		static const std::locale loc;
+		return std::use_facet <std::ctype <int>> (loc).toupper (ch);
+	}
+	inline int tolower (int ch)
+	{
+		if (ch < -1) return ch;
+		static const std::locale loc;
+		return std::use_facet <std::ctype <int>> (loc).tolower (ch);
+	}
+}
+template <typename ct> bool is_blank (ct &ch)
+{
+	return ch == ct (' ') || ch == ct ('\t') || ch == ct ('\n');
+}
+template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>> std::basic_string <E, TR, AL> NormalizeString (const std::basic_string <E, TR, AL> &str, bool upper = false, bool includemidblank = false)
+{
+	typedef std::basic_string <E, TR, AL> string_type;
+	string_type result;
+	if (str.empty ()) return result;
+	auto begin_it = str.begin ();
+	auto end_it = str.end ();
+	while (begin_it != end_it && is_blank (*begin_it)) ++begin_it;
+	while (end_it != begin_it && is_blank (*(end_it - 1))) --end_it;
+	bool in_space = false;
+	for (auto it = begin_it; it != end_it; ++ it)
+	{
+		if (is_blank (*it))
+		{
+			if (includemidblank)
+			{
+				if (!in_space)
+				{
+					result.push_back (E (' '));
+					in_space = true;
+				}
+			}
+			else
+			{
+				result.push_back (*it);
+				in_space = true;
+			}
+		}
+		else
+		{
+			result.push_back (*it);
+			in_space = false;
+		}
+	}
+	if (upper) return l0km::toupper (result);
+	else return l0km::tolower (result);
+}
+template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>> bool IsNormalizeStringEquals (const std::basic_string <E, TR, AL> &l, const std::basic_string <E, TR, AL> &r, bool includemidblank = false)
+{
+	auto _local_strlen = [] (const E *p) -> size_t {
+		size_t cnt = 0;
+		while (*(p + cnt)) { cnt ++; }
+		return cnt;
+	};
+	const E *pl = l.c_str ();
+	const E *pr = r.c_str ();
+	while (*pl && is_blank (*pl)) ++ pl;
+	while (*pr && is_blank (*pr)) ++ pr;
+	const E *el = l.c_str () + _local_strlen (l.c_str ());
+	const E *er = r.c_str () + _local_strlen (r.c_str ());
+	while (el > pl && is_blank (*(el - 1))) --el;
+	while (er > pr && is_blank (*(er - 1))) --er;
+	while (pl < el && pr < er) 
+	{
+		if (includemidblank)
+		{
+			if (is_blank (*pl) && is_blank (*pr))
+			{
+				while (pl < el && is_blank (*pl)) ++pl;
+				while (pr < er && is_blank (*pr)) ++pr;
+				continue;
+			}
+			else if (is_blank (*pl))
+			{
+				while (pl < el && is_blank (*pl)) ++pl;
+				continue;
+			}
+			else if (is_blank (*pr))
+			{
+				while (pr < er && is_blank (*pr)) ++pr;
+				continue;
+			}
+		}
+		if (l0km::tolower (*pl) != l0km::tolower (*pr)) return false;
+		++ pl;
+		++ pr;
+	}
+	while (pl < el && is_blank (*pl)) ++ pl;
+	while (pr < er && is_blank (*pr)) ++ pr;
+	return pl == el && pr == er;
+}
+template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>> int64_t NormalizeStringCompare (const std::basic_string <E, TR, AL> &l, const std::basic_string <E, TR, AL> &r, bool includemidblank = false)
+{
+	auto _local_strlen = [] (const E *p) -> size_t {
+		size_t cnt = 0;
+		while (*(p + cnt)) { cnt ++; }
+		return cnt;
+	};
+	const E *pl = l.c_str ();
+	const E *pr = r.c_str ();
+	while (*pl && is_blank (*pl)) ++ pl;
+	while (*pr && is_blank (*pr)) ++ pr;
+	const E *el = l.c_str () + _local_strlen (l.c_str ());
+	const E *er = r.c_str () + _local_strlen (r.c_str ());
+	while (el > pl && is_blank (*(el - 1))) -- el;
+	while (er > pr && is_blank (*(er - 1))) -- er;
+	while (pl < el && pr < er)
+	{
+		if (includemidblank)
+		{
+			if (is_blank (*pl) && is_blank (*pr))
+			{
+				while (pl < el && is_blank (*pl)) ++pl;
+				while (pr < er && is_blank (*pr)) ++pr;
+				continue;
+			}
+			else if (is_blank (*pl))
+			{
+				while (pl < el && is_blank (*pl)) ++pl;
+				continue;
+			}
+			else if (is_blank (*pr))
+			{
+				while (pr < er && is_blank (*pr)) ++pr;
+				continue;
+			}
+		}
+		E chl = l0km::tolower (*pl);
+		E chr = l0km::tolower (*pr);
+		if (chl != chr) return (int64_t)chl - (int64_t)chr;
+		++ pl;
+		++ pr;
+	}
+	while (pl < el && is_blank (*pl)) ++ pl;
+	while (pr < er && is_blank (*pr)) ++ pr;
+	if (pl == el && pr == er) return 0;
+	if (pl == el) return -1;
+	if (pr == er) return 1;
+	return (int64_t)l0km::tolower (*pl) - (int64_t)l0km::tolower (*pr);
+}
+template <typename CharT> bool IsNormalizeStringEquals (const CharT *l, const CharT *r, bool includemidblank = false)
+{
+	if (!l || !r) return l == r;
+	auto skip_blank = [] (const CharT *&p)
+	{
+		while (*p && is_blank (*p)) ++ p;
+	};
+	const CharT *p1 = l;
+	const CharT *p2 = r;
+	skip_blank (p1);
+	skip_blank (p2);
+	while (*p1 && *p2)
+	{
+		CharT ch1 = l0km::tolower (*p1);
+		CharT ch2 = l0km::tolower (*p2);
+		if (ch1 != ch2) return false;
+		++ p1;
+		++ p2;
+		if (includemidblank)
+		{
+			if (is_blank (*p1) || is_blank (*p2))
+			{
+				skip_blank (p1);
+				skip_blank (p2);
+			}
+		}
+	}
+	skip_blank (p1);
+	skip_blank (p2);
+	return *p1 == 0 && *p2 == 0;
+}
+template <typename CharT> int64_t NormalizeStringCompare (const CharT *l, const CharT *r, bool includemidblank = false)
+{
+	if (!l || !r) return l ? 1 : (r ? -1 : 0);
+	auto skip_blank = [] (const CharT *&p)
+	{
+		while (*p && is_blank (*p)) ++ p;
+	};
+	const CharT *p1 = l;
+	const CharT *p2 = r;
+	skip_blank (p1);
+	skip_blank (p2);
+	while (*p1 && *p2)
+	{
+		CharT ch1 = l0km::tolower (*p1);
+		CharT ch2 = l0km::tolower (*p2);
+		if (ch1 != ch2) return (ch1 < ch2) ? -1 : 1;
+		++ p1;
+		++ p2;
+		if (includemidblank)
+		{
+			if (is_blank (*p1) || is_blank (*p2))
+			{
+				skip_blank (p1);
+				skip_blank (p2);
+			}
+		}
+	}
+	skip_blank (p1);
+	skip_blank (p2);
+	if (*p1 == 0 && *p2 == 0) return 0;
+	if (*p1 == 0) return -1;
+	return 1;
+}
+template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>> bool IsNormalizeStringEmpty (const std::basic_string <E, TR, AL> &str)
+{
+	return IsNormalizeStringEquals (str, std::basic_string <E, TR, AL> ());
+}
+template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>> std::basic_string <E, TR, AL> StringTrim (const std::basic_string <E, TR, AL> &str, bool includemidblank = false)
+{
+	typedef std::basic_string <E, TR, AL> string_type;
+	typedef typename string_type::size_type size_type;
+	if (str.empty ()) return string_type ();
+	size_type first = 0;
+	size_type last = str.size ();
+	while (first < last && is_blank (str [first])) ++first;
+	while (last > first && is_blank (str [last - 1])) --last;
+	if (first == last) return string_type ();
+	string_type result;
+	result.reserve (last - first);
+	bool in_space = false;
+	for (size_type i = first; i < last; ++ i)
+	{
+		if (is_blank (str [i]))
+		{
+			if (includemidblank)
+			{
+				if (!in_space)
+				{
+					result.push_back (E (' '));
+					in_space = true;
+				}
+			}
+			else
+			{
+				result.push_back (str [i]);
+				in_space = true;
+			}
+		}
+		else
+		{
+			result.push_back (str [i]);
+			in_space = false;
+		}
+	}
+	return result;
+}
+template <typename E, typename TR = std::char_traits<E>, typename AL = std::allocator <E>> size_t GetNormalizeStringLength (const std::basic_string <E, TR, AL> &str, bool includemidblank = false)
+{
+	typedef typename std::basic_string <E, TR, AL>::size_type size_type;
+	if (str.empty ()) return 0;
+	size_type first = 0, last = str.size ();
+	while (first < last && is_blank (str [first])) ++first;
+	while (last > first && is_blank (str [last - 1])) --last;
+	if (first == last) return 0;
+	size_t length = 0;
+	bool in_space = false;
+	for (size_type i = first; i < last; ++i)
+	{
+		if (is_blank (str [i]))
+		{
+			if (includemidblank)
+			{
+				if (!in_space)
+				{
+					++ length;
+					in_space = true;
+				}
+			}
+			else
+			{
+				++ length;
+				in_space = true;
+			}
+		}
+		else
+		{
+			++ length;
+			in_space = false;
+		}
+	}
+	return length;
+}
+namespace std
+{
+	
+	template <typename ct, typename tr = std::char_traits <ct>, typename al = std::allocator <ct>> class basic_nstring: public std::basic_string <ct, tr, al>
+	{
+		using base = std::basic_string <ct, tr, al>;
+		bool default_upper = false, default_include_blank_in_str = false;
+		public:
+		using typename base::size_type;
+		using typename base::value_type;
+		using base::base;
+		basic_nstring (): base (), default_upper (false), default_include_blank_in_str (false) {}
+		basic_nstring (const ct *pStr): base (pStr), default_upper (false), default_include_blank_in_str (false) {}
+		basic_nstring (const base &str): base (str) {}
+		basic_nstring (base &&str): base (std::move (str)) {}
+		basic_nstring (const ct *data, size_type count): base (data, count), default_upper (false), default_include_blank_in_str (false) {}
+		template <std::size_t N> basic_nstring (const ct (&arr) [N]) : base (arr, N) {}
+		template <typename InputIt> basic_nstring (InputIt first, InputIt last): base (first, last), default_upper (false), default_include_blank_in_str (false) {}
+		bool upper_default () const { return this->default_upper; }
+		bool upper_default (bool value) { return this->default_upper = value; }
+		bool include_blank_in_str_middle () const { return this->default_include_blank_in_str; }
+		bool include_blank_in_str_middle (bool value) { return this->default_include_blank_in_str = value; }
+		base normalize (bool upper, bool includemidblank) const
+		{
+			return NormalizeString <ct, tr, al> (*this, upper, includemidblank);
+		}
+		base normalize (bool upper) const
+		{
+			return this->normalize (upper, default_include_blank_in_str);
+		}
+		base normalize () const { return this->normalize (default_upper); }
+		base upper (bool includemidblank) const
+		{
+			return NormalizeString <ct, tr, al> (*this, true, includemidblank);
+		}
+		base upper () const { return this->upper (default_include_blank_in_str); }
+		base lower (bool includemidblank) const
+		{
+			return NormalizeString <ct, tr, al> (*this, false, includemidblank);
+		}
+		base lower () const { return this->lower (default_include_blank_in_str); }
+		base trim (bool includemidblank) const
+		{
+			return StringTrim <ct, tr, al> (*this, includemidblank);
+		}
+		base trim () const { return this->trim (default_include_blank_in_str); }
+		size_t length (bool includemidblank) const { return GetNormalizeStringLength (*this, includemidblank); }
+		size_t length () const { return length (default_include_blank_in_str); }
+		bool empty () const
+		{
+			return IsNormalizeStringEmpty (*this);
+		}
+		bool equals (const base &another, bool includemidblank) const
+		{
+			return IsNormalizeStringEquals <ct, tr, al> (*this, another, includemidblank);
+		}
+		bool equals (const base &another) const { return equals (another, default_include_blank_in_str); }
+		int64_t compare (const base &another, bool includemidblank) const
+		{
+			return NormalizeStringCompare <ct, tr, al> (*this, another, includemidblank);
+		}
+		int64_t compare (const base &another) const { return compare (another, default_include_blank_in_str); }
+		base &string () { return *this; }
+		base to_string (bool upper, bool includemidblank) const { return this->normalize (upper, includemidblank); }
+		base to_string (bool upper) const { return this->normalize (upper, default_include_blank_in_str); }
+		base to_string () const { return this->normalize (default_upper); }
+		bool operator == (const base &other) const { return equals (other, false); }
+		bool operator != (const base &other) const { return !equals (other, false); }
+		bool operator < (const base &other) const { return compare (other, false) < 0; }
+		bool operator > (const base &other) const { return compare (other, false) > 0; }
+		bool operator <= (const base &other) const { return compare (other, false) <= 0; }
+		bool operator >= (const base &other) const { return compare (other, false) >= 0; }
+		int64_t operator - (const base &other) const { return compare (other, false); }
+		template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>>
+		static bool equals (const std::basic_string <E> &l, const std::basic_string <E> &r, bool remove_mid_blank = false)
+		{
+			return IsNormalizeStringEquals <E, TR, AL> (l, r, remove_mid_blank);
+		}
+		template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>>
+		static int64_t compare (const std::basic_string <E> &l, const std::basic_string <E> &r, bool remove_mid_blank = false)
+		{
+			return NormalizeStringCompare <E, TR, AL> (l, r, remove_mid_blank);
+		}
+		template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>>
+		static std::basic_string <E, TR, AL> normalize (const std::basic_string <E> &str, bool to_upper = false, bool remove_mid_blank = false)
+		{
+			return NormalizeString <E, TR, AL> (str, to_upper, remove_mid_blank);
+		}
+		template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>>
+		static std::basic_string <E, TR, AL> trim (const std::basic_string <E> &str, bool remove_mid_blank = false)
+		{
+			return StringTrim <E, TR, AL> (str, remove_mid_blank);
+		}
+		template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>>
+		static size_t length (const std::basic_string <E> &str, bool remove_mid_blank = false)
+		{
+			return GetNormalizeStringLength <E, TR, AL> (str, remove_mid_blank);
+		}
+		template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>>
+		static bool empty (const std::basic_string <E> &str)
+		{
+			return IsNormalizeStringEmpty <E, TR, AL> (str);
+		}
+		template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>>
+		static std::basic_nstring <E, TR, AL> to_nstring (std::basic_string <E> &str) { return std::basic_nstring <E> (str); }
+		template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>>
+		static std::basic_nstring <E, TR, AL> toupper (const std::basic_nstring <E, TR, AL> &str) { return l0km::toupper (str); }
+		template <typename E, typename TR = std::char_traits <E>, typename AL = std::allocator <E>>
+		static std::basic_nstring <E, TR, AL> tolower (const std::basic_nstring <E, TR, AL> &str) { return l0km::tolower (str); }
+	};
+
+	typedef basic_nstring <char> nstring;
+	typedef basic_nstring <wchar_t> wnstring;
+}

priread (never using)/priread.cpp

@@ -0,0 +1,22 @@
+// priread.cpp : 定义 DLL 应用程序的导出函数。
+//
+
+#include "stdafx.h"
+#include "priread.h"
+
+
+// 这是导出变量的一个示例
+PRIREAD_API int npriread=0;
+
+// 这是导出函数的一个示例。
+PRIREAD_API int fnpriread(void)
+{
+    return 42;
+}
+
+// 这是已导出类的构造函数。
+// 有关类定义的信息，请参阅 priread.h
+Cpriread::Cpriread()
+{
+    return;
+}

priread (never using)/priread.h

@@ -0,0 +1,22 @@
+// 下列 ifdef 块是创建使从 DLL 导出更简单的
+// 宏的标准方法。此 DLL 中的所有文件都是用命令行上定义的 PRIREAD_EXPORTS
+// 符号编译的。在使用此 DLL 的
+// 任何其他项目上不应定义此符号。这样，源文件中包含此文件的任何其他项目都会将
+// PRIREAD_API 函数视为是从 DLL 导入的，而此 DLL 则将用此宏定义的
+// 符号视为是被导出的。
+#ifdef PRIREAD_EXPORTS
+#define PRIREAD_API __declspec(dllexport)
+#else
+#define PRIREAD_API __declspec(dllimport)
+#endif
+
+// 此类是从 priread.dll 导出的
+class PRIREAD_API Cpriread {
+public:
+	Cpriread(void);
+	// TODO:  在此添加您的方法。
+};
+
+extern PRIREAD_API int npriread;
+
+PRIREAD_API int fnpriread(void);

priread (never using)/priread.vcxproj

@@ -0,0 +1,182 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{99D714D9-F40D-425B-BAFA-8B41C17971A5}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>priread</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;PRIREAD_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_WINDOWS;_USRDLL;PRIREAD_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;PRIREAD_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;_WINDOWS;_USRDLL;PRIREAD_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Text Include="ReadMe.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="localeex.h" />
+    <ClInclude Include="nstring.h" />
+    <ClInclude Include="prifile.h" />
+    <ClInclude Include="priread.h" />
+    <ClInclude Include="stdafx.h" />
+    <ClInclude Include="targetver.h" />
+    <ClInclude Include="themeinfo.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="dllmain.cpp">
+      <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</CompileAsManaged>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+      </PrecompiledHeader>
+      <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</CompileAsManaged>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+      </PrecompiledHeader>
+      <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</CompileAsManaged>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+      </PrecompiledHeader>
+      <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</CompileAsManaged>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+      </PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="priread.cpp" />
+    <ClCompile Include="stdafx.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

priread (never using)/priread.vcxproj.filters

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="源文件">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="头文件">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="资源文件">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <Text Include="ReadMe.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="stdafx.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="targetver.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="priread.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="prifile.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="nstring.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="localeex.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="themeinfo.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="stdafx.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="priread.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="dllmain.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

priread (never using)/stdafx.cpp

@@ -0,0 +1,8 @@
+// stdafx.cpp : 只包括标准包含文件的源文件
+// priread.pch 将作为预编译头
+// stdafx.obj 将包含预编译类型信息
+
+#include "stdafx.h"
+
+// TODO: 在 STDAFX.H 中引用任何所需的附加头文件，
+//而不是在此文件中引用

priread (never using)/stdafx.h

@@ -0,0 +1,20 @@
+// stdafx.h : 标准系统包含文件的包含文件，
+// 或是经常使用但不常更改的
+// 特定于项目的包含文件
+//
+
+#pragma once
+
+#include "targetver.h"
+
+#define WIN32_LEAN_AND_MEAN             // 从 Windows 头中排除极少使用的资料
+// Windows 头文件: 
+#include <windows.h>
+
+
+#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS      // 某些 CString 构造函数将是显式的
+
+#include <atlbase.h>
+#include <atlstr.h>
+
+// TODO:  在此处引用程序需要的其他头文件

priread (never using)/targetver.h

@@ -0,0 +1,8 @@
+#pragma once
+
+// 包括 SDKDDKVer.h 将定义可用的最高版本的 Windows 平台。
+
+// 如果要为以前的 Windows 平台生成应用程序，请包括 WinSDKVer.h，并将
+// 将 _WIN32_WINNT 宏设置为要支持的平台，然后再包括 SDKDDKVer.h。
+
+#include <SDKDDKVer.h>

priread (never using)/themeinfo.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <Windows.h>
+
+bool IsHighContrastEnabled ()
+{
+	HIGHCONTRAST hc = {sizeof (HIGHCONTRAST)};
+	if (SystemParametersInfo (SPI_GETHIGHCONTRAST, sizeof (hc), &hc, 0)) return (hc.dwFlags & HCF_HIGHCONTRASTON) != 0;
+	return false;
+}
+enum class HighContrastTheme
+{
+	None,
+	Black,
+	White,
+	Other
+};
+HighContrastTheme GetHighContrastTheme ()
+{
+	HIGHCONTRAST hc = {sizeof (HIGHCONTRAST)};
+	if (!SystemParametersInfo (SPI_GETHIGHCONTRAST, sizeof (hc), &hc, 0)) return HighContrastTheme::None;
+	if (!(hc.dwFlags & HCF_HIGHCONTRASTON)) return HighContrastTheme::None;
+	COLORREF bgColor = GetSysColor (COLOR_WINDOW);
+	COLORREF textColor = GetSysColor (COLOR_WINDOWTEXT);
+	int brightnessBg = (GetRValue (bgColor) + GetGValue (bgColor) + GetBValue (bgColor)) / 3;
+	int brightnessText = (GetRValue (textColor) + GetGValue (textColor) + GetBValue (textColor)) / 3;
+	if (brightnessBg < brightnessText) return HighContrastTheme::Black;
+	else if (brightnessBg > brightnessText) return HighContrastTheme::White;
+	else return HighContrastTheme::Other;
+}
+int GetDPI ()
+{
+	HDC hDC = GetDC (NULL);
+	int DPI_A = (int)(((double)GetDeviceCaps (hDC, 118) / (double)GetDeviceCaps (hDC, 8)) * 100);
+	int DPI_B = (int)(((double)GetDeviceCaps (hDC, 88) / 96) * 100);
+	ReleaseDC (NULL, hDC);
+	if (DPI_A == 100) return DPI_B;
+	else if (DPI_B == 100) return DPI_A;
+	else if (DPI_A == DPI_B) return DPI_A;
+	else return 0;
+}