Common.cpp File Reference

#include "../CascLib.h"
#include "../CascCommon.h"

Include dependency graph for Common.cpp:

Macros
#define	__CASCLIB_SELF__
#define	STKSIZ   (8*sizeof(void*) - 2)
#define	SWAP_ENTRIES(index1, index2)

Functions
int	GetLastError ()
void	SetLastError (int nError)
void	CopyString (char *szTarget, const char *szSource, size_t cchLength)
void	CopyString (wchar_t *szTarget, const char *szSource, size_t cchLength)
void	CopyString (char *szTarget, const wchar_t *szSource, size_t cchLength)
char *	CascNewStr (const char *szString, size_t nCharsToReserve)
wchar_t *	CascNewStr (const wchar_t *szString, size_t nCharsToReserve)
TCHAR *	CascNewStrFromAnsi (const char *szBegin, const char *szEnd)
TCHAR *	CombinePath (const TCHAR *szDirectory, const TCHAR *szSubDir)
TCHAR *	CombinePathAndString (const TCHAR *szPath, const char *szString, size_t nLength)
size_t	NormalizeFileName (const unsigned char *NormTable, char *szNormName, const char *szFileName, size_t cchMaxChars)
size_t	NormalizeFileName_UpperBkSlash (char *szNormName, const char *szFileName, size_t cchMaxChars)
size_t	NormalizeFileName_LowerSlash (char *szNormName, const char *szFileName, size_t cchMaxChars)
ULONGLONG	CalcFileNameHash (const char *szFileName)
int	ConvertDigitToInt32 (const TCHAR *szString, PDWORD PtrValue)
int	ConvertStringToInt08 (const char *szString, PDWORD PtrValue)
int	ConvertStringToInt32 (const TCHAR *szString, size_t nMaxDigits, PDWORD PtrValue)
int	ConvertStringToBinary (const char *szString, size_t nMaxDigits, LPBYTE pbBinary)
char *	StringFromBinary (LPBYTE pbBinary, size_t cbBinary, char *szBuffer)
char *	StringFromMD5 (LPBYTE md5, char *szBuffer)
const wchar_t *	GetPlainFileName (const wchar_t *szFileName)
const char *	GetPlainFileName (const char *szFileName)
bool	CheckWildCard (const char *szString, const char *szWildCard)
bool	IsValidMD5 (LPBYTE pbMd5)
bool	VerifyDataBlockHash (void *pvDataBlock, DWORD cbDataBlock, LPBYTE expected_md5)
void	CalculateDataBlockHash (void *pvDataBlock, DWORD cbDataBlock, LPBYTE md5_hash)
void	qsort_pointer_array (void **base, size_t num, int(*compare)(const void *, const void *, const void *), const void *context)

Variables
unsigned char	AsciiToLowerTable_Slash [256]
unsigned char	AsciiToUpperTable_BkSlash [256]
unsigned char	IntToHexChar [] = "0123456789abcdef"
static int	nLastError = ERROR_SUCCESS

Macro Definition Documentation

#define __CASCLIB_SELF__

#define STKSIZ   (8*sizeof(void*) - 2)

#define SWAP_ENTRIES	(		index1,
			index2
	)

Value:

{ \
 temp = base[index1]; \
 base[index1] = base[index2]; \
 base[index2] = temp; \
}

Function Documentation

ULONGLONG CalcFileNameHash

(

const char *

szFileName

)

{
 char szNormName[MAX_PATH+1];
 uint32_t dwHashHigh = 0;
 uint32_t dwHashLow = 0;
 size_t nLength;

 // Normalize the file name - convert to uppercase, slashes to backslashes
 nLength = NormalizeFileName_UpperBkSlash(szNormName, szFileName, MAX_PATH);

 // Calculate the HASH value of the normalized file name
 hashlittle2(szNormName, nLength, &dwHashHigh, &dwHashLow);
 return ((ULONGLONG)dwHashHigh << 0x20) | dwHashLow;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CalculateDataBlockHash	(	void *	pvDataBlock,
		DWORD	cbDataBlock,
		LPBYTE	md5_hash
	)

{
 hash_state md5_state;

 md5_init(&md5_state);
 md5_process(&md5_state, (unsigned char *)pvDataBlock, cbDataBlock);
 md5_done(&md5_state, md5_hash);
}

Here is the call graph for this function:

char* CascNewStr	(	const char *	szString,
		size_t	nCharsToReserve
	)

{
 char * szNewString = NULL;
 size_t nLength;

 if(szString != NULL)
 {
 nLength = strlen(szString);
 szNewString = CASC_ALLOC(char, nLength + nCharsToReserve + 1);
 if(szNewString != NULL)
 {
 memcpy(szNewString, szString, nLength);
 szNewString[nLength] = 0;
 }
 }

 return szNewString;
}

Here is the caller graph for this function:

wchar_t* CascNewStr	(	const wchar_t *	szString,
		size_t	nCharsToReserve
	)

{
 wchar_t * szNewString = NULL;
 size_t nLength;

 if(szString != NULL)
 {
 nLength = wcslen(szString);
 szNewString = CASC_ALLOC(wchar_t, nLength + nCharsToReserve + 1);
 if(szNewString != NULL)
 {
 memcpy(szNewString, szString, nLength * sizeof(wchar_t));
 szNewString[nLength] = 0;
 }
 }

 return szNewString;
}

TCHAR* CascNewStrFromAnsi	(	const char *	szBegin,
		const char *	szEnd
	)

{
 TCHAR * szNewString = NULL;

 // Only if the entry is valid
 if(szBegin != NULL && szEnd > szBegin)
 {
 // Allocate and copy the string
 szNewString = CASC_ALLOC(TCHAR, (szEnd - szBegin + 1));
 if(szNewString != NULL)
 CopyString(szNewString, szBegin, (szEnd - szBegin));
 }

 // Return the string
 return szNewString;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool CheckWildCard	(	const char *	szString,
		const char *	szWildCard
	)

{
 const char * szWildCardPtr;

 for(;;)
 {
 // If there is '?' in the wildcard, we skip one char
 while(szWildCard[0] == '?')
 {
 if(szString[0] == 0)
 return false;

 szWildCard++;
 szString++;
 }

 // Handle '*'
 szWildCardPtr = szWildCard;
 if(szWildCardPtr[0] != 0)
 {
 if(szWildCardPtr[0] == '*')
 {
 szWildCardPtr++;

 if(szWildCardPtr[0] == '*')
 continue;

 if(szWildCardPtr[0] == 0)
 return true;

 if(AsciiToUpperTable_BkSlash[szWildCardPtr[0]] == AsciiToUpperTable_BkSlash[szString[0]])
 {
 if(CheckWildCard(szString, szWildCardPtr))
 return true;
 }
 }
 else
 {
 if(AsciiToUpperTable_BkSlash[szWildCardPtr[0]] != AsciiToUpperTable_BkSlash[szString[0]])
 return false;

 szWildCard = szWildCardPtr + 1;
 }

 if(szString[0] == 0)
 return false;
 szString++;
 }
 else
 {
 return (szString[0] == 0) ? true : false;
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

TCHAR* CombinePath	(	const TCHAR *	szDirectory,
		const TCHAR *	szSubDir
	)

{
 TCHAR * szFullPath = NULL;
 TCHAR * szPathPtr;
 size_t nLength1 = 0;
 size_t nLength2 = 0;

 // Calculate lengths of each part
 if(szDirectory != NULL)
 {
 // Get the length of the directory
 nLength1 = _tcslen(szDirectory);

 // Cut all ending backslashes
 while(nLength1 > 0 && szDirectory[nLength1 - 1] == _T(PATH_SEPARATOR))
 nLength1--;
 }

 if(szSubDir != NULL)
 {
 // Cut all leading backslashes
 while(szSubDir[0] == _T(PATH_SEPARATOR))
 szSubDir++;

 // Get the length of the subdir
 nLength2 = _tcslen(szSubDir);

 // Cut all ending backslashes
 while(nLength2 > 0 && szSubDir[nLength2 - 1] == _T(PATH_SEPARATOR))
 nLength2--;
 }

 // Allocate space for the full path
 szFullPath = szPathPtr = CASC_ALLOC(TCHAR, nLength1 + nLength2 + 2);
 if(szFullPath != NULL)
 {
 // Copy the directory
 if(szDirectory != NULL && nLength1 != 0)
 {
 memcpy(szPathPtr, szDirectory, (nLength1 * sizeof(TCHAR)));
 szPathPtr += nLength1;
 }

 // Copy the sub-directory
 if(szSubDir != NULL && nLength2 != 0)
 {
 // Append backslash to the previous one
 if(szPathPtr > szFullPath)
 *szPathPtr++ = _T(PATH_SEPARATOR);

 // Copy the string
 memcpy(szPathPtr, szSubDir, (nLength2 * sizeof(TCHAR)));
 szPathPtr += nLength2;
 }

 // Terminate the string
 szPathPtr[0] = 0;
 }

 return szFullPath;
}

Here is the caller graph for this function:

TCHAR* CombinePathAndString	(	const TCHAR *	szPath,
		const char *	szString,
		size_t	nLength
	)

{
 TCHAR * szFullPath = NULL;
 TCHAR * szSubDir;

 // Create the subdir string
 szSubDir = CASC_ALLOC(TCHAR, nLength + 1);
 if(szSubDir != NULL)
 {
 CopyString(szSubDir, szString, nLength);
 szFullPath = CombinePath(szPath, szSubDir);
 CASC_FREE(szSubDir);
 }

 return szFullPath;
}

Here is the call graph for this function:

int ConvertDigitToInt32	(	const TCHAR *	szString,
		PDWORD	PtrValue
	)

{
 BYTE Digit;

 Digit = (BYTE)(AsciiToUpperTable_BkSlash[szString[0]] - _T('0'));
 if(Digit > 9)
 Digit -= 'A' - '9' - 1;

 PtrValue[0] = Digit;
 return (Digit > 0x0F) ? ERROR_BAD_FORMAT : ERROR_SUCCESS;
}

Here is the caller graph for this function:

int ConvertStringToBinary	(	const char *	szString,
		size_t	nMaxDigits,
		LPBYTE	pbBinary
	)

{
 const char * szStringEnd = szString + nMaxDigits;
 DWORD dwCounter = 0;
 BYTE DigitValue;
 BYTE ByteValue = 0;

 // Convert the string
 while(szString < szStringEnd)
 {
 // Retrieve the digit converted to hexa
 DigitValue = (BYTE)(AsciiToUpperTable_BkSlash[szString[0]] - '0');
 if(DigitValue > 9)
 DigitValue -= 'A' - '9' - 1;
 if(DigitValue > 0x0F)
 return ERROR_BAD_FORMAT;

 // Insert the digit to the binary buffer
 ByteValue = (ByteValue << 0x04) | DigitValue;
 dwCounter++;

 // If we reached the second digit, it means that we need
 // to flush the byte value and move on
 if((dwCounter & 0x01) == 0)
 *pbBinary++ = ByteValue;
 szString++;
 }

 return ERROR_SUCCESS;
}

Here is the caller graph for this function:

int ConvertStringToInt08	(	const char *	szString,
		PDWORD	PtrValue
	)

{
 BYTE DigitOne = AsciiToUpperTable_BkSlash[szString[0]] - '0';
 BYTE DigitTwo = AsciiToUpperTable_BkSlash[szString[1]] - '0';

 // Fix the digits
 if(DigitOne > 9)
 DigitOne -= 'A' - '9' - 1;
 if(DigitTwo > 9)
 DigitTwo -= 'A' - '9' - 1;

 // Combine them into a value
 PtrValue[0] = (DigitOne << 0x04) | DigitTwo;
 return (DigitOne <= 0x0F && DigitTwo <= 0x0F) ? ERROR_SUCCESS : ERROR_BAD_FORMAT;
}

Here is the caller graph for this function:

int ConvertStringToInt32	(	const TCHAR *	szString,
		size_t	nMaxDigits,
		PDWORD	PtrValue
	)

{
 // The number of digits must be even
 assert((nMaxDigits & 0x01) == 0);
 assert(nMaxDigits <= 8);

 // Prepare the variables
 PtrValue[0] = 0;
 nMaxDigits >>= 1;

 // Convert the string up to the number of digits
 for(size_t i = 0; i < nMaxDigits; i++)
 {
 BYTE DigitOne;
 BYTE DigitTwo;

 DigitOne = (BYTE)(AsciiToUpperTable_BkSlash[szString[0]] - _T('0'));
 if(DigitOne > 9)
 DigitOne -= 'A' - '9' - 1;

 DigitTwo = (BYTE)(AsciiToUpperTable_BkSlash[szString[1]] - _T('0'));
 if(DigitTwo > 9)
 DigitTwo -= 'A' - '9' - 1;

 if(DigitOne > 0x0F || DigitTwo > 0x0F)
 return ERROR_BAD_FORMAT;

 PtrValue[0] = (PtrValue[0] << 0x08) | (DigitOne << 0x04) | DigitTwo;
 szString += 2;
 }

 return ERROR_SUCCESS;
}

Here is the caller graph for this function:

void CopyString	(	char *	szTarget,
		const char *	szSource,
		size_t	cchLength
	)

{
 memcpy(szTarget, szSource, cchLength);
 szTarget[cchLength] = 0;
}

Here is the caller graph for this function:

void CopyString	(	wchar_t *	szTarget,
		const char *	szSource,
		size_t	cchLength
	)

{
 mbstowcs(szTarget, szSource, cchLength);
 szTarget[cchLength] = 0;
}

void CopyString	(	char *	szTarget,
		const wchar_t *	szSource,
		size_t	cchLength
	)

{
 wcstombs(szTarget, szSource, cchLength);
 szTarget[cchLength] = 0;
}

int GetLastError

(

)

{
 return nLastError;
}

Here is the caller graph for this function:

const wchar_t* GetPlainFileName

(

const wchar_t *

szFileName

)

{
 const wchar_t * szPlainName = szFileName;

 while(*szFileName != 0)
 {
 if(*szFileName == '\\' || *szFileName == '/')
 szPlainName = szFileName + 1;
 szFileName++;
 }

 return szPlainName;
}

Here is the caller graph for this function:

const char* GetPlainFileName

(

const char *

szFileName

)

{
 const char * szPlainName = szFileName;

 while(*szFileName != 0)
 {
 if(*szFileName == '\\' || *szFileName == '/')
 szPlainName = szFileName + 1;
 szFileName++;
 }

 return szPlainName;
}

bool IsValidMD5

(

LPBYTE

pbMd5

)

{
 BYTE BitSummary = 0;

 // The MD5 is considered invalid of it is zeroed
 BitSummary |= pbMd5[0x00] | pbMd5[0x01] | pbMd5[0x02] | pbMd5[0x03] | pbMd5[0x04] | pbMd5[0x05] | pbMd5[0x06] | pbMd5[0x07];
 BitSummary |= pbMd5[0x08] | pbMd5[0x09] | pbMd5[0x0A] | pbMd5[0x0B] | pbMd5[0x0C] | pbMd5[0x0D] | pbMd5[0x0E] | pbMd5[0x0F];
 return (BitSummary != 0);
}

Here is the caller graph for this function:

size_t NormalizeFileName	(	const unsigned char *	NormTable,
		char *	szNormName,
		const char *	szFileName,
		size_t	cchMaxChars
	)

{
 char * szNormNameEnd = szNormName + cchMaxChars;
 size_t i;

 // Normalize the file name: ToLower + BackSlashToSlash
 for(i = 0; szFileName[0] != 0 && szNormName < szNormNameEnd; i++)
 *szNormName++ = NormTable[*szFileName++];

 // Terminate the string
 szNormName[0] = 0;
 return i;
}

Here is the caller graph for this function:

size_t NormalizeFileName_LowerSlash	(	char *	szNormName,
		const char *	szFileName,
		size_t	cchMaxChars
	)

{
 return NormalizeFileName(AsciiToLowerTable_Slash, szNormName, szFileName, cchMaxChars);
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t NormalizeFileName_UpperBkSlash	(	char *	szNormName,
		const char *	szFileName,
		size_t	cchMaxChars
	)

{
 return NormalizeFileName(AsciiToUpperTable_BkSlash, szNormName, szFileName, cchMaxChars);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void qsort_pointer_array	(	void **	base,
		size_t	num,
		int(*)(const void *, const void *, const void *)	compare,
		const void *	context
	)

{
 size_t lo, hi; /* ends of sub-array currently sorting */
 size_t mid; /* points to middle of subarray */
 size_t loguy, higuy; /* traveling pointers for partition step */
 size_t size; /* size of the sub-array */
 size_t lostk[STKSIZ], histk[STKSIZ];
 void * temp;
 int stkptr; /* stack for saving sub-array to be processed */

 /* validation section */
 assert(base != NULL);
 assert(compare != NULL);

 if (num < 2)
 return; /* nothing to do */

 stkptr = 0; /* initialize stack */

 lo = 0;
 hi = (num-1); /* initialize limits */

 /* this entry point is for pseudo-recursion calling: setting
 lo and hi and jumping to here is like recursion, but stkptr is
 preserved, locals aren't, so we preserve stuff on the stack */
recurse:

 size = (hi - lo) + 1; /* number of el's to sort */

 /* First we pick a partitioning element. The efficiency of the
 algorithm demands that we find one that is approximately the median
 of the values, but also that we select one fast. We choose the
 median of the first, middle, and last elements, to avoid bad
 performance in the face of already sorted data, or data that is made
 up of multiple sorted runs appended together. Testing shows that a
 median-of-three algorithm provides better performance than simply
 picking the middle element for the latter case. */

 mid = lo + (size / 2); /* find middle element */

 /* Sort the first, middle, last elements into order */
 if (compare(context, base[lo], base[mid]) > 0) {
 SWAP_ENTRIES(lo, mid);
 }
 if (compare(context, base[lo], base[hi]) > 0) {
 SWAP_ENTRIES(lo, hi);
 }
 if (compare(context, base[mid], base[hi]) > 0) {
 SWAP_ENTRIES(mid, hi);
 }

 /* We now wish to partition the array into three pieces, one consisting
 of elements <= partition element, one of elements equal to the
 partition element, and one of elements > than it. This is done
 below; comments indicate conditions established at every step. */

 loguy = lo;
 higuy = hi;

 /* Note that higuy decreases and loguy increases on every iteration,
 so loop must terminate. */
 for (;;) {
 /* lo <= loguy < hi, lo < higuy <= hi,
 A[i] <= A[mid] for lo <= i <= loguy,
 A[i] > A[mid] for higuy <= i < hi,
 A[hi] >= A[mid] */

 /* The doubled loop is to avoid calling comp(mid,mid), since some
 existing comparison funcs don't work when passed the same
 value for both pointers. */

 if (mid > loguy) {
 do {
 loguy ++;
 } while (loguy < mid && compare(context, base[loguy], base[mid]) <= 0);
 }
 if (mid <= loguy) {
 do {
 loguy ++;
 } while (loguy <= hi && compare(context, base[loguy], base[mid]) <= 0);
 }

 /* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,
 either loguy > hi or A[loguy] > A[mid] */

 do {
 higuy --;
 } while (higuy > mid && compare(context, base[higuy], base[mid]) > 0);

 /* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,
 either higuy == lo or A[higuy] <= A[mid] */

 if (higuy < loguy)
 break;

 /* if loguy > hi or higuy == lo, then we would have exited, so
 A[loguy] > A[mid], A[higuy] <= A[mid],
 loguy <= hi, higuy > lo */

 SWAP_ENTRIES(loguy, higuy);

 /* If the partition element was moved, follow it. Only need
 to check for mid == higuy, since before the swap,
 A[loguy] > A[mid] implies loguy != mid. */

 if (mid == higuy)
 mid = loguy;

 /* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top
 of loop is re-established */
 }

 /* A[i] <= A[mid] for lo <= i < loguy,
 A[i] > A[mid] for higuy < i < hi,
 A[hi] >= A[mid]
 higuy < loguy
 implying:
 higuy == loguy-1
 or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */

 /* Find adjacent elements equal to the partition element. The
 doubled loop is to avoid calling comp(mid,mid), since some
 existing comparison funcs don't work when passed the same value
 for both pointers. */

 higuy ++;
 if (mid < higuy) {
 do {
 higuy --;
 } while (higuy > mid && compare(context, base[higuy], base[mid]) == 0);
 }
 if (mid >= higuy) {
 do {
 higuy --;
 } while (higuy > lo && compare(context, base[higuy], base[mid]) == 0);
 }

 /* OK, now we have the following:
 higuy < loguy
 lo <= higuy <= hi
 A[i] <= A[mid] for lo <= i <= higuy
 A[i] == A[mid] for higuy < i < loguy
 A[i] > A[mid] for loguy <= i < hi
 A[hi] >= A[mid] */

 /* We've finished the partition, now we want to sort the subarrays
 [lo, higuy] and [loguy, hi].
 We do the smaller one first to minimize stack usage.
 We only sort arrays of length 2 or more.*/

 if ( higuy - lo >= hi - loguy ) {
 if (lo < higuy) {
 lostk[stkptr] = lo;
 histk[stkptr] = higuy;
 ++stkptr;
 } /* save big recursion for later */

 if (loguy < hi) {
 lo = loguy;
 goto recurse; /* do small recursion */
 }
 }
 else {
 if (loguy < hi) {
 lostk[stkptr] = loguy;
 histk[stkptr] = hi;
 ++stkptr; /* save big recursion for later */
 }

 if (lo < higuy) {
 hi = higuy;
 goto recurse; /* do small recursion */
 }
 }

 /* We have sorted the array, except for any pending sorts on the stack.
 Check if there are any, and do them. */

 --stkptr;
 if (stkptr >= 0) {
 lo = lostk[stkptr];
 hi = histk[stkptr];
 goto recurse; /* pop subarray from stack */
 }
 else
 return; /* all subarrays done */
}

void SetLastError

(

int

nError

)

{
 nLastError = nError;
}

Here is the caller graph for this function:

char* StringFromBinary	(	LPBYTE	pbBinary,
		size_t	cbBinary,
		char *	szBuffer
	)

{
 char * szSaveBuffer = szBuffer;

 // Convert the string to the array of MD5
 // Copy the blob data as text
 for(size_t i = 0; i < cbBinary; i++)
 {
 *szBuffer++ = IntToHexChar[pbBinary[0] >> 0x04];
 *szBuffer++ = IntToHexChar[pbBinary[0] & 0x0F];
 pbBinary++;
 }

 // Terminate the string
 *szBuffer = 0;
 return szSaveBuffer;
}

Here is the caller graph for this function:

char* StringFromMD5	(	LPBYTE	md5,
		char *	szBuffer
	)

{
 return StringFromBinary(md5, MD5_HASH_SIZE, szBuffer);
}

Here is the call graph for this function:

bool VerifyDataBlockHash	(	void *	pvDataBlock,
		DWORD	cbDataBlock,
		LPBYTE	expected_md5
	)

{
 hash_state md5_state;
 BYTE md5_digest[MD5_HASH_SIZE];

 // Don't verify the block if the MD5 is not valid.
 if(!IsValidMD5(expected_md5))
 return true;

 // Calculate the MD5 of the data block
 md5_init(&md5_state);
 md5_process(&md5_state, (unsigned char *)pvDataBlock, cbDataBlock);
 md5_done(&md5_state, md5_digest);

 // Does the MD5's match?
 return (memcmp(md5_digest, expected_md5, MD5_HASH_SIZE) == 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

unsigned char AsciiToLowerTable_Slash[256]

Initial value:

=
{
 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
 0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x5B, 0x2F, 0x5D, 0x5E, 0x5F,
 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
}

unsigned char AsciiToUpperTable_BkSlash[256]

Initial value:

=
{
 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x5C,
 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
 0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
}

unsigned char IntToHexChar[] = "0123456789abcdef"

int nLastError = ERROR_SUCCESS

static