534 lines
11 KiB
C++
534 lines
11 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1996 - 1997.
|
|
//
|
|
// File: utils.cxx
|
|
//
|
|
// Contents: general purpose utility functions
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// Coupling:
|
|
//
|
|
// Notes: right now only operator<< for different types
|
|
// must init crit sec for rand on your own
|
|
//
|
|
// History: 9-11-1996 benl Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
#include "pch.hxx"
|
|
|
|
#include <stdio.h>
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include "mydebug.hxx"
|
|
#include "utils.hxx"
|
|
#include "randpeak.hxx"
|
|
|
|
static CRITICAL_SECTION gcsRand;
|
|
static BOOLEAN gfInit;
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: PrintGuid
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [file] --
|
|
// [guid] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 1-27-1997 benl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void PrintGuid(FILE * file, const GUID & guid)
|
|
{
|
|
INT iIndex;
|
|
|
|
fprintf(file, "%08x-%04hx-%04hx-", guid.Data1, guid.Data2, guid.Data3);
|
|
for (iIndex=0;iIndex < 8; iIndex++)
|
|
{
|
|
fprintf(file,"%01x", guid.Data4[iIndex]);
|
|
}
|
|
} //PrintGuid
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: MyRand
|
|
//
|
|
// Synopsis: simple rand function
|
|
//
|
|
// Arguments: [dwLimit] --
|
|
//
|
|
// Returns: values btwn 0 and dwLimit inclusively
|
|
//
|
|
// History: 10-23-1996 benl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
INT MyRand(INT iLimit)
|
|
{
|
|
return RandomInRange(0, iLimit);
|
|
} //MyRand
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: MyRand64
|
|
//
|
|
// Synopsis: like above but for 64 bit integers
|
|
//
|
|
// Arguments: [llLimit] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 2-12-1997 benl Created
|
|
//
|
|
// Notes: This works poorly - need a true 64bit random number generator
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
LONGLONG MyRand64(LONGLONG llLimit)
|
|
{
|
|
LARGE_INTEGER liTemp;
|
|
|
|
liTemp.LowPart = Random32();
|
|
liTemp.HighPart = Random32();
|
|
|
|
return liTemp.QuadPart % llLimit;
|
|
} //MyRand64
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: MyRand16
|
|
//
|
|
// Synopsis: like above but for 16 bit integers
|
|
//
|
|
// Arguments: [sLimit] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 5-15-1997 benl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
SHORT MyRand16(SHORT sLimit)
|
|
{
|
|
return (SHORT) RandomInRange(0, sLimit);
|
|
} // MyRand16
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: MySRand
|
|
//
|
|
// Synopsis: srand for threads
|
|
//
|
|
// Arguments: [dwBase] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-30-1996 benl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
VOID MySRand(DWORD & dwBase)
|
|
{
|
|
if (!gfInit)
|
|
{
|
|
InitializeCriticalSection(&gcsRand);
|
|
gfInit = TRUE;
|
|
}
|
|
|
|
EnterCriticalSection(&gcsRand);
|
|
dwBase++;
|
|
SeedRandom32(dwBase);
|
|
LeaveCriticalSection(&gcsRand);
|
|
} //MySRand
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: SwapBuffers
|
|
//
|
|
// Synopsis: Swap two differently sized buffers such that
|
|
// the info is split correctly between them
|
|
// i.e if one is 40 bytes and the second 60 bytes
|
|
// after its done the first one contains 40 bytes from the orig 2nd buffer
|
|
// and the 2nd one contains the following orig 20 bytes of the 2nd buffer and
|
|
// then the orig 40. bytes of the first buffer
|
|
//
|
|
// Arguments: [cbBuf1] -- len of pBuffer1
|
|
// [pBuffer1] -- buffer1
|
|
// [cbBuf2] -- len of pBuffer2
|
|
// [pBuffer2] -- buffer2
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 9-29-1997 benl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void SwapBuffers(INT cbBuf1, BYTE * pBuffer1, INT cbBuf2, BYTE * pBuffer2)
|
|
{
|
|
BYTE * pTemp = new BYTE[cbBuf1];
|
|
INT iFirst;
|
|
INT iSecond;
|
|
INT iThird;
|
|
|
|
memcpy(pTemp, pBuffer1, cbBuf1);
|
|
|
|
iFirst = min(cbBuf1, cbBuf2);
|
|
memcpy(pBuffer1, pBuffer2, iFirst);
|
|
if (iFirst < cbBuf1)
|
|
{
|
|
memcpy(pBuffer1 + iFirst, pTemp, cbBuf1 - iFirst);
|
|
iSecond = 0;
|
|
iThird = cbBuf1 + iFirst;
|
|
} else
|
|
{
|
|
memcpy(pBuffer2, pBuffer1 + iFirst, cbBuf2 - iFirst);
|
|
iSecond = cbBuf2 - iFirst;
|
|
iThird = 0;
|
|
}
|
|
memcpy(pBuffer2 + iSecond, pTemp + iThird, cbBuf2 - iSecond);
|
|
|
|
if (pTemp)
|
|
{
|
|
delete[] pTemp;
|
|
}
|
|
} // SwapBuffers
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: PrintByte
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [byte] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-14-1996 benl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void PrintByte(BYTE byte)
|
|
{
|
|
printf("%02hx", byte);
|
|
|
|
} //PrintByte
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: PrintWord
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [bytes] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-14-1996 benl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void PrintWord(LPBYTE bytes)
|
|
{
|
|
PrintByte(bytes[0]);
|
|
printf(" ");
|
|
PrintByte(bytes[1]);
|
|
} //PrintWord
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: PrintDWord
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [bytes] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-14-1996 benl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void PrintDWord(LPBYTE bytes)
|
|
{
|
|
PrintWord(bytes);
|
|
printf(" ");
|
|
PrintWord(bytes + 2);
|
|
} //PrintDWord
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: DumpRawBytes
|
|
//
|
|
// Synopsis: Helper output function
|
|
//
|
|
// Arguments: [pBytes] --
|
|
// [cBytes] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-14-1996 benl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void DumpRawBytes(BYTE * pBytes, UINT cBytes)
|
|
{
|
|
UINT iIndex;
|
|
UINT iIndex2;
|
|
|
|
if (0 == cBytes)
|
|
{
|
|
printf("Empty Buffer\n");
|
|
}
|
|
|
|
/*
|
|
if (cBytes < 16)
|
|
{
|
|
printf("%04x ",iIndex * 16);
|
|
for(iIndex=0; iIndex < cBytes; iIndex++)
|
|
{
|
|
PrintByte(*(pBytes + iIndex));
|
|
printf(" ");
|
|
}
|
|
}
|
|
*/
|
|
|
|
for (iIndex=0;iIndex < cBytes / 16; iIndex++)
|
|
{
|
|
printf("%04x ",iIndex * 16);
|
|
PrintDWord(pBytes + (iIndex * 16));
|
|
printf(" ");
|
|
PrintDWord(pBytes + (iIndex * 16 + 4));
|
|
printf(" ");
|
|
PrintDWord(pBytes + (iIndex * 16 + 8));
|
|
printf(" ");
|
|
PrintDWord(pBytes + (iIndex * 16 + 12));
|
|
|
|
printf(" ");
|
|
|
|
for (iIndex2=0;iIndex2 < 16; iIndex2++)
|
|
{
|
|
if (isgraph(pBytes[(iIndex*16) + iIndex2]))
|
|
{
|
|
printf("%c", pBytes[(iIndex*16) + iIndex2]);
|
|
} else
|
|
{
|
|
printf(".");
|
|
}
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
//print trailing bytes
|
|
printf("%04x ", ((cBytes / 16) * 16));
|
|
|
|
for (iIndex=0; iIndex < 16; iIndex++)
|
|
{
|
|
if (iIndex < cBytes % 16)
|
|
{
|
|
PrintByte(*(pBytes + ((cBytes / 16) * 16) + iIndex));
|
|
printf(" ");
|
|
} else
|
|
{
|
|
printf(" ");
|
|
}
|
|
//add byte separator if necc.
|
|
if (iIndex && (iIndex % 7 == 0))
|
|
{
|
|
printf(" ");
|
|
}
|
|
|
|
}
|
|
|
|
for (iIndex2=0; iIndex2 < cBytes % 16; iIndex2++)
|
|
{
|
|
if (isgraph(*(pBytes + ((cBytes / 16) * 16) + iIndex2)))
|
|
{
|
|
printf("%c", *(pBytes + ((cBytes / 16) * 16) + iIndex2));
|
|
} else
|
|
{
|
|
printf(".");
|
|
}
|
|
}
|
|
|
|
|
|
printf("\n");
|
|
} //DumpRawBytes
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: DumpRawDwords
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [pDwords] --
|
|
// [cBytes] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 8-25-1998 benl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void DumpRawDwords(DWORD * pDwords, UINT cBytes)
|
|
{
|
|
UINT iIndex;
|
|
UINT iIndex2;
|
|
BYTE * pBytes;
|
|
|
|
if (0 == cBytes)
|
|
{
|
|
printf("Empty Buffer\n");
|
|
}
|
|
|
|
for (iIndex=0; iIndex < cBytes / 16; iIndex++)
|
|
{
|
|
printf("%04x ",iIndex * 16);
|
|
|
|
printf("%08x ", pDwords[iIndex * 4]);
|
|
printf("%08x ", pDwords[iIndex * 4 + 1]);
|
|
printf("%08x ", pDwords[iIndex * 4 + 2]);
|
|
printf("%08x ", pDwords[iIndex * 4 + 3]);
|
|
|
|
printf(" ");
|
|
|
|
pBytes = (BYTE *) (pDwords + (iIndex * 4));
|
|
for (iIndex2=0; iIndex2 < 16; iIndex2++)
|
|
{
|
|
if (isgraph(pBytes[iIndex2]))
|
|
{
|
|
printf("%c", pBytes[iIndex2]);
|
|
} else
|
|
{
|
|
printf(".");
|
|
}
|
|
}
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
//print trailing dwords
|
|
printf("%04x ", ((cBytes / 16) * 16));
|
|
|
|
for (iIndex=0; iIndex < 4; iIndex++)
|
|
{
|
|
if (iIndex * 4 < cBytes % 16)
|
|
{
|
|
printf("%08x", pDwords[((cBytes / 16) * 4) +iIndex]);
|
|
printf(" ");
|
|
} else
|
|
{
|
|
printf(" ");
|
|
}
|
|
}
|
|
|
|
printf(" ");
|
|
|
|
pBytes = (BYTE *) (pDwords + ((cBytes / 16) * 4));
|
|
for (iIndex2=0; iIndex2 < cBytes % 16; iIndex2++)
|
|
{
|
|
if (isgraph(*(pBytes + iIndex2)))
|
|
{
|
|
printf("%c", *(pBytes + iIndex2));
|
|
} else
|
|
{
|
|
printf(".");
|
|
}
|
|
}
|
|
|
|
|
|
printf("\n");
|
|
} // DumpRawDwords
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HexStrToInt64
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [szIn] --
|
|
// [i64Out] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 5-30-96 benl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void HexStrToInt64(LPCTSTR szIn, __int64 & i64Out)
|
|
{
|
|
int i;
|
|
const TCHAR * szTmp = szIn;
|
|
|
|
i64Out = 0;
|
|
|
|
/*
|
|
if (szTmp[0] != '0' && szTmp[1] != 'x') {
|
|
return;
|
|
}
|
|
//move past prefix
|
|
szTmp+=2;
|
|
*/
|
|
while (*szTmp != _T('\0') &&
|
|
(_istdigit(*szTmp) || (_totlower(*szTmp) >= 'a' && _totlower(*szTmp) <= 'f')))
|
|
{
|
|
i64Out *= 16;
|
|
if (_istdigit(*szTmp))
|
|
{
|
|
i64Out += *szTmp - _T('0');
|
|
} else
|
|
{
|
|
i64Out += _totlower(*szTmp) - _T('a') + 10;
|
|
}
|
|
szTmp++;
|
|
} //endwhile
|
|
} //HexStrToInt64
|
|
|