unibase.h

数字签名的例子

	return wcsncpy(pwzDst, pwzSrc, uLen);
#endif
}

UAPI PWSTR UWStrCat(PWSTR pwzDst, PCWSTR pwzSrc)
{
#ifdef _WINSTR
	return lstrcatW(pwzDst, pwzSrc);
#else
	return wcscat(pwzDst, pwzSrc);
#endif
}

UAPI INT UWStrCmp(PCWSTR pwzStr1, PCWSTR pwzStr2)
{
#ifdef _WINSTR
	return lstrcmpW(pwzStr1, pwzStr2);
#else
	return wcscmp(pwzStr1, pwzStr2);
#endif
}

UAPI INT UWStrCmpI(PCWSTR pwzStr1, PCWSTR pwzStr2)
{
#ifdef _WINSTR
	return lstrcmpiW(pwzStr1, pwzStr2);
#else
	return _wcsicmp(pwzStr1, pwzStr2);
#endif
}

UAPI INT UWStrCmpN(PCWSTR pwzStr1, PCWSTR pwzStr2, UINT uLen)
{
#ifdef _SHLSTR
	return StrCmpNW(pwzStr1, pwzStr2, uLen);
#else
	return wcsncmp(pwzStr1, pwzStr2, uLen);
#endif
}

UAPI INT UWStrCmpNI(PCWSTR pwzStr1, PCWSTR pwzStr2, UINT uLen)
{
#ifdef _SHLSTR
	return StrCmpNIW(pwzStr1, pwzStr2, uLen);
#else
	return _wcsnicmp(pwzStr1, pwzStr2, uLen);
#endif
}

UAPI PWSTR UWStrChr(PCWSTR pwzStr, WCHAR wChr)
{
#ifdef _SHLSTR
	return (PWSTR) StrChrW(pwzStr, wChr);
#else
	return (PWSTR) wcschr(pwzStr, wChr);
#endif
}

UAPI PWSTR UWStrRChr(PCWSTR pwzStr, WCHAR wChr)
{
#ifdef _SHLSTR
	return (PWSTR) StrRChrW(pwzStr, NULL, wChr);
#else
	return (PWSTR) wcsrchr(pwzStr, wChr);
#endif
}

UAPI PWSTR UWStrStr(PCWSTR pwzStr1, PCWSTR pwzStr2)
{
#ifdef _SHLSTR
	return (PWSTR) StrStrW(pwzStr1, pwzStr2);
#else
	return (PWSTR) wcsstr(pwzStr1, pwzStr2);
#endif
}

UAPI PWSTR UWStrStrI(PCWSTR pwzStr1, PCWSTR pwzStr2)
{
#ifdef _SHLSTR
	return (PWSTR) StrStrIW(pwzStr1, pwzStr2);
#else
	PWSTR p = (PWSTR) pwzStr1;
	while (*p)
	{
		PWSTR s1 = p;
		PWSTR s2 = (PWSTR) pwzStr2;

		while (*s1 && *s2 && UChrEqual((TCHAR) *s1, (TCHAR) *s2))
		{
			s1++;
			s2++;
		}

		if (*s2 == 0)
		{
			return p;
		}

		p++;
	}
	return NULL;
#endif
}

UAPI PWSTR UWStrRep(PWSTR pwzStr, WCHAR wFind, WCHAR wRep)
{
	PWSTR p = pwzStr;
	for (; *p; p++)
	{
		if (*p == wFind)
		{
			*p = wRep;
		}
	}
	return pwzStr;
}

UAPI PWSTR UWStrTrim(PWSTR pwzStr, WCHAR cTrim)
{
	if (*pwzStr == cTrim)
	{
		PWSTR p = pwzStr + UWStrLen(pwzStr) - 1;
		if (*p == cTrim)
		{
			*p = 0;
		}
		return pwzStr + 1;
	}
	return pwzStr;
}

UAPI PWSTR UWStrToUpper(PWSTR pwzStr)
{
#ifdef _WINSTR
	return CharUpperW(pwzStr);
#else
	return _wcsupr(pwzStr);
#endif
}

UAPI PWSTR UWStrToLower(PWSTR pwzStr)
{
#ifdef _WINSTR
	return CharLowerW(pwzStr);
#else
	return _wcslwr(pwzStr);
#endif
}

UAPI INT UWStrToInt(PCWSTR pwzStr)
{
#ifdef _SHLSTR
	INT i = 0;
	StrToIntExW(pwzStr, STIF_SUPPORT_HEX, &i);
	return i;
#else
	return _wtoi(pwzStr);
#endif
}

UAPI PWSTR UWStrFromInt(PWSTR pwzDst, INT iVal)
{
#ifdef _WINSTR
	wsprintfW(pwzDst, L"%d", iVal);
	return pwzDst;
#else
	return _itow(iVal, pwzDst, 10);
#endif
}

#ifdef _WINSTR
#define UWStrPrint wsprintfW
#define UWStrPrintV wvsprintfW
#else
#define UWStrPrint swprintf
#define UWStrPrintV vswprintf
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// File
UAPI HANDLE UFileOpen(PCTSTR ptzPath, DWORD dwAccess)
{
	DWORD dwCreate = (dwAccess == UFILE_WRITE) ? CREATE_ALWAYS : ((dwAccess == UFILE_APPEND) ? OPEN_ALWAYS : OPEN_EXISTING);
	HANDLE hFile = CreateFile(ptzPath, dwAccess, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwCreate, 0, NULL);
	if (hFile == INVALID_HANDLE_VALUE)
	{
		return NULL;
	}
	if (dwAccess == UFILE_APPEND)
	{
		SetFilePointer(hFile, 0, NULL, FILE_END);
	}
	return hFile;
}

UAPI BOOL UFileClose(HANDLE hFile)
{
	return CloseHandle(hFile);
}

UAPI UINT UFileRead(HANDLE hFile, PVOID pvData, UINT uSize)
{
	DWORD dwRead = 0;
	ReadFile(hFile, pvData, uSize, &dwRead, NULL);
	return dwRead;
}

UAPI UINT UFileWrite(HANDLE hFile, PCVOID pvData, UINT uSize)
{
	DWORD dwWrite = 0;
	WriteFile(hFile, pvData, uSize, &dwWrite, NULL);
	return dwWrite;
}

UAPI UINT UFileSeek(HANDLE hFile, INT iOffset, DWORD dwOrigin)
{
	return SetFilePointer(hFile, iOffset, NULL, dwOrigin);
}

UAPI UINT UFileTell(HANDLE hFile)
{
	return UFileSeek(hFile, 0, UFILE_CURRENT);
}

UAPI UINT UFileGetSize(HANDLE hFile)
{
	DWORD dwSize = GetFileSize(hFile, NULL);
	return (dwSize == INVALID_FILE_SIZE) ? 0 : dwSize;
}

UAPI BOOL UFileSetSize(HANDLE hFile, UINT uSize)
{
	UFileSeek(hFile, uSize, FILE_CURRENT);
	return SetEndOfFile(hFile);
}

UAPI PVOID UFileLoad(PCTSTR ptzPath, PVOID pvData, PUINT puSize)
{
	HANDLE hFile = UFileOpen(ptzPath, UFILE_READ);
	if (hFile)
	{
		UINT uSize = UFileGetSize(hFile);
		if (puSize)
		{
			if (*puSize > uSize)
			{
				*puSize = uSize;
			}
		}
		else
		{
			puSize = &uSize;
		}
		if (!pvData)
		{
			pvData = (PBYTE) UMemAlloc(uSize + 16);
		}
		if (pvData)
		{
			*puSize = UFileRead(hFile, pvData, *puSize);
			((PBYTE) pvData)[uSize] = 0;
			((PBYTE) pvData)[uSize + 1] = 0;
		}
		UFileClose(hFile);
	}
	return pvData;
}

UAPI UINT UFileSave(PCTSTR ptzPath, PCVOID pvData, UINT uSize, DWORD dwAccess)
{
	UINT uResult = 0;
	HANDLE hFile = UFileOpen(ptzPath, dwAccess);
	if (hFile)
	{
		uResult = UFileWrite(hFile, pvData, uSize);
		UFileClose(hFile);
	}
	return uResult;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// File Management
UAPI BOOL UFileDelete(PCTSTR ptzPath)
{
	return DeleteFile(ptzPath);
}

UAPI BOOL UFileCopy(PCTSTR ptzPath, PCTSTR ptzNewPath)
{
	return CopyFile(ptzPath, ptzNewPath, FALSE);
}

UAPI BOOL UFileMove(PCTSTR ptzPath, PCTSTR ptzNewPath)
{
	return MoveFile(ptzPath, ptzNewPath);
}

UAPI BOOL UFileExist(PCTSTR ptzPath)
{
	HANDLE hFile = UFileOpen(ptzPath, UFILE_READ);
	if (hFile)
	{
		UFileClose(hFile);
		return TRUE;
	}
	return FALSE;
}

UAPI BOOL UDirExist(PCTSTR ptzPath)
{
	WIN32_FILE_ATTRIBUTE_DATA fa;
	return GetFileAttributesEx(ptzPath, GetFileExInfoStandard, &fa) && (fa.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
}

UAPI BOOL UDirCreate(PTSTR ptzDir)
{
	for (PTSTR p = ptzDir; p = UStrChr(p, '\\'); *p++ = '\\')
	{
		*p = 0;
		if (!UDirExist(ptzDir))
		{
			CreateDirectory(ptzDir, NULL);
		}
	}
	return TRUE;
}

UAPI BOOL UDirDelete(PCTSTR ptzDir)
{
	return RemoveDirectory(ptzDir);
}

UAPI PTSTR UDirMakePath(PTSTR ptzDir, PCTSTR ptzSub)
{
	PTSTR p = UStrChr(ptzDir, 0);
	if (p[-1] != '\\')
	{
		*p++ = '\\';
	}
	UStrCopy(p, ptzSub);
	return ptzDir;
}

UAPI PTSTR UDirSplitPath(PTSTR ptzPath)
{
	PTSTR p = UStrRChr(ptzPath, '\\');
	if (p)
	{
		*p = 0;
		return p + 1;
	}

	return ptzPath;
}

UAPI PTSTR UDirGetTempDir(PTSTR ptzDir)
{
	GetTempPath(MAX_PATH, ptzDir);
	return ptzDir;
}

UAPI PTSTR UDirGetTempFile(PTSTR ptzPath)
{
	UDirGetTempDir(ptzPath);
	GetTempFileName(ptzPath, TEXT("UNI"), 0, ptzPath);
	return ptzPath;
}

UAPI PTSTR UDirGetAppPath(PTSTR ptzPath)
{
#ifdef WINCE
	extern HINSTANCE g_hInst;
	GetModuleFileName(g_hInst, ptzPath, MAX_PATH);
#else
	MEMORY_BASIC_INFORMATION m = {0};
	VirtualQuery(UDirGetAppPath, &m, sizeof(MEMORY_BASIC_INFORMATION));
	GetModuleFileName((HMODULE) m.AllocationBase, ptzPath, MAX_PATH);
#endif
	return ptzPath;
}

UAPI PTSTR UDirGetAppFile(PTSTR ptzPath, PCTSTR ptzFile)
{
	PTSTR p;
	UDirGetAppPath(ptzPath);
	p = UStrRChr(ptzPath, '\\');
	if (p == NULL)
	{
		p = UStrChr(ptzPath, 0);
	}
	return UStrCopy(p + 1, ptzFile);
}

UAPI PTSTR UDirGetAppExt(PTSTR ptzPath, PCTSTR ptzExt)
{
	PTSTR p;
	UDirGetAppPath(ptzPath);
	p = UStrRChr(ptzPath, '.');
	if (p == NULL)
	{
		p = UStrChr(ptzPath, 0);
	}
	return UStrCopy(p + 1, ptzExt);
}

UAPI PTSTR UDirGetCurrent(PTSTR ptzDir)
{
#ifdef GetCurrentDirectory
	GetCurrentDirectory(MAX_PATH, ptzDir);
	return ptzDir;
#else
	UDirGetAppPath(ptzDir);
	return UDirSplitPath(ptzDir);
#endif
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Thread
UAPI HANDLE UThreadCreate(UPROC upProc, PVOID pvParam)
{
	DWORD dwThread;
	return CreateThread(NULL, 0, upProc, pvParam, 0, &dwThread);
}

UAPI BOOL UThreadClose(HANDLE hThread)
{
	return CloseHandle(hThread);
}

UAPI BOOL UThreadTerminate(HANDLE hThread)
{
	return TerminateThread(hThread, 0);
}

UAPI BOOL UThreadSuspend(HANDLE hThread)
{
	return SuspendThread(hThread);
}

UAPI BOOL UThreadResume(HANDLE hThread)
{
	return ResumeThread(hThread);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Misc
UAPI UINT UGetRandom()
{
	return rand();
}

UAPI VOID UGetTime(PUTIME pTime)
{
	GetLocalTime(pTime);
}

UAPI UINT UGetTimeStamp()
{
	return GetTickCount();
}

UAPI VOID UTrack(PCTSTR ptzFormat, ...)
{
	DWORD i;
	va_list va;
	TCHAR tz[MAX_STR];

	va_start(va, ptzFormat);
	i = UStrPrintV(tz, ptzFormat, va);
	va_end(va);

#if defined(_LOGFILE)
	UFileSave(TEXT("UniDebug.txt"), tz, i * sizeof(TCHAR), UFILE_APPEND);
#elif defined(_LOGMSG)
	MessageBox(NULL, tz, TEXT("UniDebug"), MB_ICONINFORMATION | MB_TOPMOST);
#elif defined(_LOGCON)
	WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), tz, i, &i, NULL);
#else
	OutputDebugString(tz);
#endif
}

UAPI VOID UAssert(PCTSTR ptzExp, PCTSTR ptzFile, UINT uLine)
{
	UINT i;
	TCHAR tzText[MAX_STR];
	TCHAR tzModule[MAX_PATH];

	UStrPrint(tzText,
		TEXT("Assertion failed!\n\n")
		TEXT("Program: %s\n")
		TEXT("File: %s\n")
		TEXT("Line: %d\n\n")
		TEXT("Expression: %s\n\n")
		TEXT("Press Retry to debug the application - JIT must be enabled"),
		UDirGetAppPath(tzModule), ptzFile, uLine, ptzExp);

	i = MessageBox(NULL, tzText, TEXT("UniDebug"), MB_ICONERROR | MB_ABORTRETRYIGNORE);
	if (i == IDABORT)
	{
		ExitProcess(0);
	}
	else if (i == IDRETRY)
	{
		DebugBreak();
	}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Debug
#ifdef __FUNCTION__
#define __FUNCFILE__				TEXT(__FUNCTION__)
#else
#define __FUNCFILE__				TEXT(__FILE__)
#endif

#ifdef __cplusplus
class CAutoTrack
{
private:
	UINT m_uLine;
	PCTSTR m_ptzName;
public:
	CAutoTrack(PCTSTR ptzName, UINT uLine): m_uLine(uLine), m_ptzName(ptzName)
	{
		UTrack(TEXT("Enter %s:%u\r\n"), ptzName, uLine);
	}
	~CAutoTrack()
	{
		UTrack(TEXT("Leave %s:%u\r\n"), m_ptzName, m_uLine);
	}
};
#define __AutoTrack()				CAutoTrack at(__FUNCFILE__, __LINE__)
#else
#define __AutoTrack()				UTrack(TEXT("Track %s:%u\r\n"), __FUNCFILE__, __LINE__)
#endif

#ifdef _DEBUG
#define _Track						UTrack
#define _AutoTrack()				__AutoTrack()
#define _LineTrack()				UTrack(TEXT("Track %s:%u\r\n"), __FUNCFILE__, __LINE__)
#else
#define _Track
#define _AutoTrack()
#define _LineTrack()
#endif

#ifdef _DEBUG
#define _Assert(e)					(VOID) ((e) || (UAssert(TEXT(#e), TEXT(__FILE__), __LINE__), 0))
#else
#define _Assert(e)					((VOID) 0)
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////