int CCommClient::SendData(TCHAR *pData,int nLen)
{
//防止多线程调用出错
CLocalLock lock(&m_lockSend);
if(m_socket == NULL)
{
return -1;
}
DWORD dwLen = (nLen + 1 + sizeof(DWORD)) * sizeof(TCHAR);
TCHAR *buff=new TCHAR[dwLen];
ZeroMemory(buff, dwLen * sizeof(TCHAR));
#ifdef _UNICODE
memcpy_s((char*)buff, sizeof(DWORD), (char*)&dwLen, sizeof(DWORD));
wmemcpy_s(&buff[sizeof(DWORD)], dwLen - sizeof(DWORD) - sizeof(TCHAR), pData, nLen);
#else
memcpy(buff, sizeof(DWORD), &dwLen,sizeof(DWORD));
memcpy(&buff[sizeof(DWORD)], dwLen - sizeof(DWORD) - sizeof(TCHAR), pData,nLen);
#endif
int nSendByte = send(m_socket,(char*)buff,dwLen,0);
delete []buff;
return nSendByte;
}
/// @brief 属性网格元素,获取指定项的值.
/// @param hEle 元素句柄.
/// @param itemID 项ID标示符.
/// @param pOut 接收内容缓冲区.
/// @param len pOut缓冲区长度
void WINAPI XPGrid_GetItemValue(HELE hEle,int itemID,wchar_t *pOut,int len)
{
IsPGridDebug(hEle,__FUNCTION__);
propertyGrid_ *pObj=(propertyGrid_*)hEle;
PGridItem_ *pItem=PGrid_GetItem(hEle,itemID);
if(NULL==pItem) return;
switch(pItem->type)
{
case PGRID_STRING:
{
wmemcpy_s(pOut,len,pItem->pValue,wcslen(pItem->pValue));
}break;
case PGRID_EDIT_FILE:
case PGRID_EDIT:
{
if(pItem->hEle)
XEdit_GetText(pItem->hEle,pOut,len);
}break;
case PGRID_COMBOBOX:
{
if(pItem->hEle)
XComboBox_GetText(pItem->hEle,pOut,len);
}break;
case PGRID_CHOOSECOLOR:
{
if(len<7) return;
wchar_t color[8]={0};
XEdit_GetText(pItem->hEle,pOut,7);
}break;
}
}
void Memcpy(wchar_t* target, wchar_t const* source, size_t count)
{
#if defined(WIN32)
errno_t result = wmemcpy_s(target, count, source, count);
(void)result; // 0 on success
#else
wmemcpy(target, source, count);
#endif
}
template <> int Translate(
wchar_t* srcBuf,
size_t srcCharLen,
wchar_t* destBuf,
size_t destCharLen )
{
if ( destCharLen > 0 )
{
_ASSERT( destBuf != NULL );
srcCharLen = std::min( srcCharLen, destCharLen );
errno_t err = wmemcpy_s( destBuf, srcCharLen, srcBuf, srcCharLen );
_ASSERT( err == 0 );
UNREFERENCED_PARAMETER( err );
}
return srcCharLen;
}
array<__wchar_t>^ zDBBinaryReader::ToChars(int offset, int length)
{
int cb; // Local size information
const wchar_t* pwchData; // Pointer into raw data
array<__wchar_t>^ rg; // Managed char array of data
PinnedCharPtr pinRg; // Pinned pointer into rg[]
int cch; // Unicode character count
CHECK_DISPOSED(m_disposed);
if(offset < 0) throw gcnew ArgumentException();
if(length < 0) throw gcnew ArgumentException();
if((offset % sizeof(wchar_t)) != 0) throw gcnew ArgumentException();
if((length % sizeof(wchar_t)) != 0) throw gcnew ArgumentException();
// When accessing things as Unicode character data, ask SQLite for a
// specific size that will properly adjusted as necessary
cb = sqlite3_column_bytes16(m_pStatement->Handle, m_ordinal);
if((offset + length) > cb) throw gcnew ArgumentOutOfRangeException();
// Special case: If the caller wants zero bytes, don't go pinning
// pointers and copying nothing. Just return what they want
if(length == 0) return gcnew array<__wchar_t>(0);
cch = length / sizeof(wchar_t); // Calculate character count
rg = gcnew array<__wchar_t>(cch); // Create return array
pinRg = &rg[0]; // Pin and get a pointer
// Only copy the amount of data that the caller is looking for from
// the SQLite buffer into the managed Char array buffer
pwchData = reinterpret_cast<const wchar_t*>(sqlite3_column_text16(m_pStatement->Handle, m_ordinal));
wmemcpy_s(pinRg, cch, pwchData + (offset / sizeof(wchar_t)), cch);
return rg;
}
void TestMove_s( void )
{
wchar_t buf[128];
wchar_t s2[] = L"VALUE";
wchar_t str[] = L"VALUE";
wchar_t src1[100] = L"hello";
wchar_t src2[7] = L"goodbye";
wchar_t dst1[6], dst2[5], dst3[5];
wchar_t sc1[100] = L"good";
wchar_t sc2[6] = L"hello";
wchar_t sc3[6] = L"hello";
wchar_t sc4[7] = L"abc";
wchar_t sc5[1000] = L"bye";
int violations = NumViolations;
/* wcstok_s */
static wchar_t str1[] = L"?a???b,,,#c";
static wchar_t str2[] = L"\t \t";
static wchar_t str3[] = L"?a???b,,,#c";
wchar_t *t, *ptr1, *ptr2, *ptr3;
rsize_t max1 = ARRAYCOUNT( str1 );
rsize_t max2 = ARRAYCOUNT( str2 );
rsize_t max3 = ARRAYCOUNT( str3 );
/***********************************************************************/
/* set constraint-handler */
/***********************************************************************/
set_constraint_handler_s( my_constraint_handler );
/***********************************************************************/
/* memcpy_s */
/***********************************************************************/
// printf( "Test memcpys (%s).\n", ProgramName );
/* Test the "good" case */
VERIFY( wmemcpy_s( buf, ARRAYCOUNT( buf ), s2, 0 ) == 0 );
VERIFY( wmemcpy_s( buf, ARRAYCOUNT( buf ), s2, 1 + wcslen( s2 ) ) == 0 );
VERIFY( wmemcpy_s( buf, wcslen( s2 ) + 2, s2, 1 + wcslen( s2 ) ) == 0 );
VERIFY( wcslen( buf ) == wcslen( L"VALUE" ) );
VERIFY( wcscmp( buf, L"VALUE" ) == 0 );
VERIFY( NumViolations == violations );
/* Test various failing cases */
/* Test runtime-constraint violations */
VERIFY( wmemcpy_s( buf, 3, s2, wcslen( s2 ) ) != 0 );
VERIFY( buf[0] == L'\0' );
VERIFY( NumViolations == ++violations );
VERIFY( wmemcpy_s( NULL, ARRAYCOUNT( buf ), s2, wcslen( s2 ) ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wmemcpy_s( buf, ARRAYCOUNT( buf ), NULL, wcslen( s2 ) ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wmemcpy_s( buf, ARRAYCOUNT( buf ), s2, sizeof( buf ) / sizeof( buf[0] )+ 1 ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wmemcpy_s( buf, ARRAYCOUNT( buf ), buf + 1, wcslen( s2 ) ) != 0 );
VERIFY( NumViolations == ++violations );
#if RSIZE_MAX != SIZE_MAX
VERIFY( wmemcpy_s( buf, ARRAYCOUNT( buf ), s2, ~0 ) != 0 );
VERIFY( NumViolations == ++violations );
#endif
/***********************************************************************/
/* memmove_s */
/***********************************************************************/
// printf( "Test memmove (%s).\n", ProgramName );
/* Test the "good" cases */
VERIFY( wmemmove_s( buf, ARRAYCOUNT( buf ), s2, 0 ) == 0 );
VERIFY( wmemmove_s( buf, ARRAYCOUNT( buf ), s2, 1 + wcslen( s2 ) ) == 0 );
VERIFY( wmemmove_s( buf, ARRAYCOUNT( buf ), buf + 1, 1 + wcslen( s2 ) ) == 0 );
VERIFY( wmemmove_s( buf, 1 + wcslen( s2 ), s2, 1 + wcslen( s2 ) ) == 0 );
VERIFY( wcslen( buf ) == wcslen( L"VALUE" ) );
VERIFY( wcscmp( buf, L"VALUE" ) == 0 );
VERIFY( NumViolations == violations );
/* Test various failing cases */
/* Test runtime-constraint violations */
VERIFY( wmemmove_s( buf, 3, s2, wcslen( s2 ) ) != 0 );
VERIFY( buf[0] == L'\0' );
VERIFY( NumViolations == ++violations );
VERIFY( wmemmove_s( NULL, ARRAYCOUNT( buf ), s2, wcslen( s2 ) ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wmemmove_s( buf, ARRAYCOUNT( buf ), NULL, wcslen( s2 ) ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wmemmove_s( buf, ARRAYCOUNT( buf ), s2, ARRAYCOUNT( buf ) + 1 ) != 0 );
VERIFY( NumViolations == ++violations );
#if RSIZE_MAX != SIZE_MAX
VERIFY( wmemmove_s( buf, ~0, s2, wcslen( s2 ) ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wmemmove_s( buf, ARRAYCOUNT( buf ), s2, ~0 ) != 0 );
VERIFY( NumViolations == ++violations );
#endif
/***********************************************************************/
/* wcscpy_s */
/***********************************************************************/
// printf( "Test memcpy (%s).\n", ProgramName );
/* Test the "good" cases */
VERIFY( wcscpy_s( buf, ARRAYCOUNT( buf ), s2 ) == 0 );
VERIFY( wcscpy_s( buf, ARRAYCOUNT( buf ), s2 ) == 0 );
VERIFY( wcscpy_s( buf, wcslen( s2 ) + 1, s2 ) == 0 );
VERIFY( wcslen( buf ) == wcslen( L"VALUE" ) );
VERIFY( wcscmp( buf, L"VALUE" ) == 0 );
VERIFY( NumViolations == violations );
/* Test various failing cases */
/* Test runtime-constraint violations */
VERIFY( wcscpy_s( buf, 3, s2 ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( buf[0] == L'\0' );
VERIFY( wcscpy_s( NULL, ARRAYCOUNT( buf ), s2 ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wcscpy_s( buf, ARRAYCOUNT( buf ), NULL ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wcscpy_s( buf, 5, s2 ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wcscpy_s( buf, ARRAYCOUNT( buf ), buf + 1 ) != 0 );
VERIFY( NumViolations == ++violations );
#if RSIZE_MAX != SIZE_MAX
VERIFY( wcscpy_s( buf, ~0, s2 ) != 0 );
VERIFY( NumViolations == ++violations );
#endif
/***********************************************************************/
/* wcscat_s */
/***********************************************************************/
// printf( "Test wcscat (%s).\n", ProgramName );
wcscpy( sc1,src1 );
VERIFY( wcscmp( sc1,src1 ) == 0 );
VERIFY( wcscat_s( sc1, 100, sc5 ) == 0 );
VERIFY( wcscmp( sc1, L"hellobye") == 0 );
VERIFY( wcscat_s( sc2, 6, L"" ) == 0 );
VERIFY( wcscat_s( sc3, 6, L"X" ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( sc3[0] == L'\0');
VERIFY( wcscat_s(sc4, 7, L"defghijklmn") != 0);
VERIFY( NumViolations == ++violations );
VERIFY( wcscmp(sc4, L"" ) == 0);
/***********************************************************************/
/* wcsnlen_s */
/***********************************************************************/
// printf( "Test wcsnlen (%s).\n", ProgramName );
/* Test the "good" case */
VERIFY( wcsnlen_s( str, ARRAYCOUNT( str ) ) == wcslen( str ) );
VERIFY( wcsnlen_s( str, 4 ) == 4 );
VERIFY( wcsnlen_s( str, 0 ) == 0 );
VERIFY( wcsnlen_s( NULL, 1000 ) == 0 );
/* Test various failing cases */
/* No runtime-constraint violations to test */
VERIFY( NumViolations == violations );
/***********************************************************************/
/* wcsncpy_s */
/***********************************************************************/
// printf( "Test wcsncpy (%s).\n", ProgramName );
/* Test the "good" case */
VERIFY( wcsncpy_s( buf, ARRAYCOUNT( buf ), s2, 0 ) == 0 );
VERIFY( wcsncpy_s( buf, ARRAYCOUNT( buf ), s2, wcslen( s2 ) ) == 0 );
VERIFY( wcsncpy_s( buf, wcslen( s2 ) + 1, s2, wcslen( s2 ) ) == 0 );
VERIFY( wcslen( buf ) == wcslen( L"VALUE" ) );
VERIFY( wcscmp( buf, L"VALUE" ) == 0 );
VERIFY( NumViolations == violations );
VERIFY( wcsncpy_s( dst1, 6, src1, 100 ) == 0 );
VERIFY( wcscmp( dst1, src1 ) == 0 );
VERIFY( wcsncpy_s( dst3, 5, src2, 4 ) == 0 );
/* Test various failing cases */
/* Test runtime-constraint violations */
VERIFY( wcsncpy_s( buf, 3, s2, wcslen( s2 ) ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( buf[0] == '\0' );
VERIFY( wcsncpy_s( NULL, ARRAYCOUNT( buf ), s2, wcslen( s2 ) ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wcsncpy_s( buf, ARRAYCOUNT( buf ), NULL, wcslen( s2 ) ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wcsncpy_s( buf, ARRAYCOUNT( buf ), buf + 1, wcslen( s2 ) ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wcsncpy_s( dst2, 5, src2, 7 ) != 0 );
VERIFY( NumViolations == ++violations );
#if RSIZE_MAX != SIZE_MAX
VERIFY( wcsncpy_s( buf, ~0, s2, wcslen( s2 ) ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( wcsncpy_s( buf, ARRAYCOUNT( buf ), s2, ~0 ) != 0 );
VERIFY( NumViolations == ++violations );
#endif
/***********************************************************************/
/* wcsncat_s */
/***********************************************************************/
// printf( "Test wcsncat (%s).\n", ProgramName );
wcscpy( sc1, L"good" );
wcscpy( sc2, L"hello" );
wcscpy( sc3, L"hello" );
wcscpy( sc4, L"abc" );
VERIFY( wcsncat_s( sc1, 100, sc5, 1000 ) == 0);
VERIFY( wcscmp( sc1, L"goodbye" ) == 0 );
VERIFY( wcsncat_s( sc2, 6, L"", 1 ) == 0 );
VERIFY( wcsncat_s( sc4, 7, L"defghijklmn", 3 ) == 0 );
VERIFY( wcscmp( sc4, L"abcdef" ) == 0 );
/* Test runtime-constraint violations */
VERIFY( wcsncat_s( sc3, 6, L"XXX", 3 ) != 0 );
VERIFY( NumViolations == ++violations );
VERIFY( sc3[0] == L'\0');
/***********************************************************************/
/* wcstok_s */
/***********************************************************************/
// printf( "Test wcstok (%s).\n", ProgramName );
VERIFY( (t = wcstok_s( str1, &max1, L"?", &ptr1 )) != NULL ); /* points to the token "a" */
VERIFY( wcscmp( t, L"a" ) == 0 );
VERIFY( (t = wcstok_s( NULL, &max1, L",", &ptr1 )) != NULL ); /* points to the token "??b" */
VERIFY( wcscmp( t, L"??b" ) == 0 );
VERIFY( NULL == wcstok_s( str2, &max2, L" \t", &ptr2 ) ); /* null pointer */
VERIFY( NumViolations == violations );
VERIFY( (t = wcstok_s( NULL, &max1, L"#,", &ptr1 )) != NULL ); /* points to the token "c" */
VERIFY( wcscmp( t, L"c" ) == 0 );
VERIFY( ptr1 != NULL );
VERIFY( NumViolations == violations );
VERIFY( NULL == wcstok_s( NULL, &max1, L"#,", &ptr1 ) ); /* at the end */
wcscpy( str1, str3 );
max1 = ARRAYCOUNT( str1 );
VERIFY( NULL == wcstok_s( str1, &max1, str3, &ptr3 ) ); /* only delimiter chars */
// printf( "Test wcstok rtc (%s).\n", ProgramName );
/* Test runtime-constraint violations */
ptr1 = NULL;
VERIFY( NULL == wcstok_s( NULL, &max1, L"?", &ptr1 ) ); /* null pointer */
VERIFY( NumViolations == ++violations );
VERIFY( NULL == wcstok_s( str3, NULL, L"?", &ptr1 ) );
VERIFY( NumViolations == ++violations );
VERIFY( NULL == wcstok_s( str3, &max3, NULL, &ptr1 ) );
VERIFY( NumViolations == ++violations );
VERIFY( NULL == wcstok_s( str3, &max3, L"?", NULL ) );
VERIFY( NumViolations == ++violations );
ptr3 = NULL;
VERIFY( NULL == wcstok_s( NULL, &max3, L"?", &ptr3 ) );
VERIFY( NumViolations == ++violations );
#if RSIZE_MAX != SIZE_MAX
max1 = ~0;
VERIFY( NULL == wcstok_s( str3, &max1, L"?", &ptr1 ) );
VERIFY( NumViolations == ++violations );
#endif
}
int test_wmemcpy_s (void)
{
errno_t rc;
uint32_t i;
rsize_t len;
unsigned int testno = 0;
printf("\nTesting wmemcpy_s:\n");
/*--------------------------------------------------*/
/* 1 Test for NULL destination check */
printf("Test #%d:\n", ++testno);
rc = wmemcpy_s(NULL, LEN, mem2, LEN);
if (rc != ESNULLP) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
}
/*--------------------------------------------------*/
/* 2 Test for zero length destination */
printf("Test #%d:\n", ++testno);
rc = wmemcpy_s(mem1, 0, mem2, LEN);
if (rc != ESZEROL) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
}
/*--------------------------------------------------*/
/* 3 Test for too large destination size */
printf("Test #%d:\n", ++testno);
rc = wmemcpy_s(mem1, RSIZE_MAX_MEM+1, mem2, LEN);
if (rc != ESLEMAX) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
}
/*--------------------------------------------------*/
/* 4 Test for NULL source check */
printf("Test #%d:\n", ++testno);
rc = wmemcpy_s(mem1, LEN, NULL, LEN);
if (rc != ESNULLP) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
}
/*--------------------------------------------------*/
/* 5 Test for zero length source */
printf("Test #%d:\n", ++testno);
rc = wmemcpy_s(mem1, 10, mem2, 0);
if (rc != ESZEROL) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
}
/*--------------------------------------------------*/
/* 6 Test for too large source size */
printf("Test #%d:\n", ++testno);
rc = wmemcpy_s(mem1, LEN, mem2, RSIZE_MAX_MEM+1);
if (rc != ESLEMAX) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
}
/*--------------------------------------------------*/
/* 7 Test for destination overlaps into source buffer */
printf("Test #%d:\n", ++testno);
rc = wmemcpy_s(mem1, LEN, &mem1[20], 21);
if (rc != ESOVRLP) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
}
/*--------------------------------------------------*/
/* 8 Test for source overlaps into dest buffer */
printf("Test #%d:\n", ++testno);
rc = wmemcpy_s(&mem1[25], LEN, mem1, 26);
if (rc != ESOVRLP) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
}
/*--------------------------------------------------*/
/* 9 Test for just enough room for dest buffer before source & proper copying */
printf("Test #%d:\n", ++testno);
for (i=0; i<10; i++) { mem1[i] = 33; }
mem1[10] = 40;
for (i=11; i<LEN; i++) { mem1[i] = 44; }
rc = wmemcpy_s(mem1, 10, &mem1[10], 10);
if (rc != EOK) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
} else {
if ( mem1[0] != 40 && mem1[10] != 40) {
printf("%d - %d m1[0]=%d m1[10]=%d should be 40 \n",
__LINE__, i, mem1[0], mem1[10]);
}
for (i=1; i<10; i++) {
if (mem1[i] != 44) {
printf("%d - %d m1=%d should be 44 \n",
__LINE__, i, mem1[i]);
}
}
}
/*--------------------------------------------------*/
/* 10 */
printf("Test #%d:\n", ++testno);
for (i=0; i<LEN+1; i++) { mem1[i] = 33; }
for (i=0; i<LEN; i++) { mem2[i] = 44; }
len = LEN;
rc = wmemcpy_s(mem1, len, mem2, (len+1) );
if (rc == EOK) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
} else {
for (i=0; i<len; i++) {
if (mem1[i] != 0) {
printf("%d - %d m1=%d m2=%d \n",
__LINE__, i, mem1[i], mem2[i]);
}
}
if (mem1[i] != 33) {
printf("%d - %lu m1=%d m2=%d \n",
__LINE__, len, mem1[len], mem2[len]);
}
}
/*--------------------------------------------------*/
/* 11 */
printf("Test #%d:\n", ++testno);
for (i=0; i<LEN+2; i++) { mem1[i] = 33; }
for (i=0; i<LEN; i++) { mem2[i] = 44; }
len = LEN/2;
rc = wmemcpy_s(mem1, len, mem2, LEN);
if (rc != ESLEMAX) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
} else {
for (i=0; i<len; i++) {
if (mem1[i] != 0) {
printf("%d - %d m1=%d m2=%d \n",
__LINE__, i, mem1[i], mem2[i]);
}
}
if (mem1[len] != 33) {
printf("%d - %lu m1=%d m2=%d \n",
__LINE__, len, mem1[len], mem2[len]);
}
}
/*--------------------------------------------------*/
/* 12 */
printf("Test #%d:\n", ++testno);
for (i=0; i<LEN+2; i++) { mem1[i] = 33; }
for (i=0; i<LEN; i++) { mem2[i] = 44; }
len = LEN;
rc = wmemcpy_s(mem1, len, mem2, 0);
if (rc != ESZEROL) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
} else {
/* verify mem1 was zeroed */
for (i=0; i<len; i++) {
if (mem1[i] != 0) {
printf("%d - %d m1=%d m2=%d \n",
__LINE__, i, mem1[i], mem2[i]);
}
}
if (mem1[len] != 33) {
printf("%d - %lu m1=%d m2=%d \n",
__LINE__, len, mem1[len], mem2[len]);
}
}
/*--------------------------------------------------*/
/* 13 */
printf("Test #%d:\n", ++testno);
for (i=0; i<LEN; i++) { mem1[i] = 33; }
for (i=0; i<LEN; i++) { mem2[i] = 44; }
len = LEN;
rc = wmemcpy_s(mem1, len, mem2, RSIZE_MAX_MEM+1);
if (rc != ESLEMAX) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
} else {
/* verify mem1 was zeroed */
for (i=0; i<len; i++) {
if (mem1[i] != 0) {
printf("%d - %d m1=%d m2=%d \n",
__LINE__, i, mem1[i], mem2[i]);
}
}
if (mem1[len] == 0) {
printf("%d - %d m1=%d m2=%d \n",
__LINE__, i, mem1[i], mem2[i]);
}
}
/*--------------------------------------------------*/
/* 14 */
printf("Test #%d:\n", ++testno);
for (i=0; i<LEN; i++) { mem1[i] = 55; }
/* same ptr - no move */
rc = wmemcpy_s(mem1, LEN, mem1, LEN);
if (rc != EOK) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
}
/*--------------------------------------------------*/
/* 15 */
printf("Test #%d:\n", ++testno);
for (i=0; i<LEN; i++) { mem1[i] = 55; }
for (i=0; i<LEN; i++) { mem2[i] = 65; }
/* overlap */
len = 100;
rc = wmemcpy_s(&mem1[0], len, &mem1[10], len);
if (rc != ESOVRLP) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
} else {
for (i=0; i<len; i++) {
if (mem1[i] != 0) {
printf("%d - %d m1=%d m2=%d \n",
__LINE__, i, mem1[i], mem2[i]);
}
}
if (mem1[len] == 0) {
printf("%d - %d m1=%d m2=%d \n",
__LINE__, i, mem1[i], mem2[i]);
}
}
/*--------------------------------------------------*/
/* 16 */
printf("Test #%d:\n", ++testno);
for (i=0; i<LEN; i++) { mem1[i] = 55; }
for (i=0; i<LEN; i++) { mem2[i] = 65; }
/* overlap */
len = 100;
rc = wmemcpy_s(&mem1[10], len, &mem1[0], len);
if (rc != ESOVRLP) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
} else {
for (i=10; i<len+10; i++) {
if (mem1[i] != 0) {
printf("%d - %d m1=%d m2=%d \n",
__LINE__, i, mem1[i], mem2[i]);
}
}
}
/*--------------------------------------------------*/
/* 17 */
printf("Test #%d:\n", ++testno);
for (i=0; i<LEN; i++) { mem1[i] = 35; }
for (i=0; i<LEN; i++) { mem2[i] = 55; }
len = 5;
rc = wmemcpy_s(mem1, len, mem2, len);
if (rc != EOK) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
} else {
for (i=0; i<len; i++) {
if (mem1[i] != 55) {
printf("%d - %d m1=%d\n",
__LINE__, i, mem1[i]);
}
}
}
/*--------------------------------------------------*/
/* 18 */
printf("Test #%d:\n", ++testno);
for (i=0; i<LEN; i++) { mem1[i] = 35; }
for (i=0; i<LEN; i++) { mem2[i] = 55; }
rc = wmemcpy_s(mem1, LEN, mem2, LEN/2);
if (rc != EOK) {
printf("%s %u Error rc=%u \n",
__FUNCTION__, __LINE__, rc);
} else {
for (i=0; i<LEN/2; i++) {
if (mem1[i] != 55) {
printf("%d - %d m1=%d m2=%d \n",
__LINE__, i, mem1[i], mem2[i]);
}
}
}
/*--------------------------------------------------*/
/*--------------------------------------------------*/
return (0);
}
void CLotteryDlg::_readInfo()
{
CString strCurPath;
if ((strCurPath = _getCurPath()).IsEmpty())
return ;
wchar_t strFilename[1024];
memset(strFilename, 0, sizeof(strFilename));
//MultiByteToWideChar(CP_ACP, 0, strCurPath, strCurPath.GetLength() * sizeof(TCHAR), strFilename, strCurPath.GetLength());
wmemcpy_s(strFilename, sizeof(strFilename), (LPCTSTR)strCurPath, strCurPath.GetLength());
std::wstring strDataPath(strFilename);
strDataPath += L"data.txt";
std::ifstream infile(strDataPath.c_str());
if (!infile)
{
AfxMessageBox(L"没找到参与抽奖者数据");
return ;
}
char buf[32];
std::string strData;
PartnersInfo pi;
char separator[] = "\r\n\t ";
bool bN = false, bP = false;
while (1)
{
infile.getline(buf, sizeof(buf));
strData = buf;
size_t pos = 0;
bN = false;
for (; pos < strData.size(); ++pos)
{
if ((strData[pos] == '\t' || strData[pos] == ' '))
{
if (bN)
break;
}
else
{
bN = true;
pi._name += strData[pos];
}
}
bP = false;
for (; pos < strData.size(); ++pos)
{
if ((strData[pos] == '\t' || strData[pos] == ' '))
{
if (bP)
break;
}
else
{
bP = true;
pi._pn += strData[pos];
}
}
if ((infile.rdstate() & ifstream::eofbit) != 0)
break;
//要排除数据中出现的信息重复情况
if (find(m_PartnerInfo.begin(), m_PartnerInfo.end(), pi) == m_PartnerInfo.end())
m_PartnerInfo.push_back(pi);
pi.clear();
}
infile.close();
infile.clear();
}
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
{
Gdiplus::GdiplusStartupInput gdiplusStartupInput;
ULONG_PTR gdiplusToken;
unsigned char fail_type = 0;
// Initialize GDI+.
Gdiplus::GdiplusStartup( &gdiplusToken, &gdiplusStartupInput, NULL );
// Blocks our reading thread and various GUI operations.
InitializeCriticalSection( &pe_cs );
// Get the default message system font.
NONCLIENTMETRICS ncm = { NULL };
ncm.cbSize = sizeof( NONCLIENTMETRICS );
SystemParametersInfo( SPI_GETNONCLIENTMETRICS, sizeof( NONCLIENTMETRICS ), &ncm, 0 );
// Set our global font to the LOGFONT value obtained from the system.
hFont = CreateFontIndirect( &ncm.lfMessageFont );
// Get the row height for our listview control.
TEXTMETRIC tm;
HDC hDC = GetDC( NULL );
HFONT ohf = ( HFONT )SelectObject( hDC, hFont );
GetTextMetricsW( hDC, &tm );
SelectObject( hDC, ohf ); // Reset old font.
ReleaseDC( NULL, hDC );
row_height = tm.tmHeight + tm.tmExternalLeading + 5;
int icon_height = GetSystemMetrics( SM_CYSMICON ) + 2;
if ( row_height < icon_height )
{
row_height = icon_height;
}
// Get the system icon for each of the three file types.
SHFILEINFOA shfi = { NULL };
SHGetFileInfoA( ".bmp", FILE_ATTRIBUTE_NORMAL, &shfi, sizeof( shfi ), SHGFI_ICON | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES );
hIcon_bmp = shfi.hIcon;
SHGetFileInfoA( ".png", FILE_ATTRIBUTE_NORMAL, &shfi, sizeof( shfi ), SHGFI_ICON | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES );
hIcon_png = shfi.hIcon;
SHGetFileInfoA( ".jpg", FILE_ATTRIBUTE_NORMAL, &shfi, sizeof( shfi ), SHGFI_ICON | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES );
hIcon_jpg = shfi.hIcon;
// Initialize our window class.
WNDCLASSEX wcex;
wcex.cbSize = sizeof( WNDCLASSEX );
wcex.style = CS_VREDRAW | CS_HREDRAW;
wcex.lpfnWndProc = MainWndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon( hInstance, MAKEINTRESOURCE( IDI_ICON ) );
wcex.hCursor = LoadCursor( NULL, IDC_ARROW );
wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW );
wcex.lpszMenuName = NULL;
wcex.lpszClassName = L"thumbcache";
wcex.hIconSm = LoadIcon( wcex.hInstance, MAKEINTRESOURCE( IDI_APPLICATION ) );
if ( !RegisterClassEx( &wcex ) )
{
fail_type = 1;
goto CLEANUP;
}
wcex.lpfnWndProc = ImageWndProc;
wcex.lpszClassName = L"image";
if ( !RegisterClassEx( &wcex ) )
{
fail_type = 1;
goto CLEANUP;
}
wcex.lpfnWndProc = ScanWndProc;
wcex.lpszClassName = L"scan";
if ( !RegisterClassEx( &wcex ) )
{
fail_type = 1;
goto CLEANUP;
}
wcex.lpfnWndProc = InfoWndProc;
wcex.lpszClassName = L"info";
if ( !RegisterClassEx( &wcex ) )
{
fail_type = 1;
goto CLEANUP;
}
wcex.lpfnWndProc = PropertyWndProc;
wcex.lpszClassName = L"property";
if ( !RegisterClassEx( &wcex ) )
{
fail_type = 1;
goto CLEANUP;
}
g_hWnd_main = CreateWindow( L"thumbcache", PROGRAM_CAPTION, WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, ( ( GetSystemMetrics( SM_CXSCREEN ) - MIN_WIDTH ) / 2 ), ( ( GetSystemMetrics( SM_CYSCREEN ) - MIN_HEIGHT ) / 2 ), MIN_WIDTH, MIN_HEIGHT, NULL, NULL, NULL, NULL );
if ( !g_hWnd_main )
{
fail_type = 2;
goto CLEANUP;
}
g_hWnd_image = CreateWindow( L"image", PROGRAM_CAPTION, WS_OVERLAPPEDWINDOW, ( ( GetSystemMetrics( SM_CXSCREEN ) - MIN_WIDTH ) / 2 ), ( ( GetSystemMetrics( SM_CYSCREEN ) - MIN_HEIGHT ) / 2 ), MIN_HEIGHT, MIN_HEIGHT, NULL, NULL, NULL, NULL );
if ( !g_hWnd_image )
{
fail_type = 2;
goto CLEANUP;
}
g_hWnd_scan = CreateWindow( L"scan", L"Map File Paths to Cache Entry Hashes", WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_CLIPCHILDREN, ( ( GetSystemMetrics( SM_CXSCREEN ) - MIN_WIDTH ) / 2 ), ( ( GetSystemMetrics( SM_CYSCREEN ) - ( MIN_HEIGHT - 115 ) ) / 2 ), MIN_WIDTH, ( MIN_HEIGHT - 115 ), g_hWnd_main, NULL, NULL, NULL );
if ( !g_hWnd_scan )
{
fail_type = 2;
goto CLEANUP;
}
g_hWnd_info = CreateWindow( L"info", L"Extended Information", WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, ( ( GetSystemMetrics( SM_CXSCREEN ) - MIN_WIDTH ) / 2 ), ( ( GetSystemMetrics( SM_CYSCREEN ) - MIN_WIDTH ) / 2 ), MIN_WIDTH, MIN_WIDTH, NULL, NULL, NULL, NULL );
if ( !g_hWnd_info )
{
fail_type = 2;
goto CLEANUP;
}
g_hWnd_property = CreateWindow( L"property", L"Property Value", WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, ( ( GetSystemMetrics( SM_CXSCREEN ) - MIN_HEIGHT ) / 2 ), ( ( GetSystemMetrics( SM_CYSCREEN ) - MIN_HEIGHT ) / 2 ), MIN_HEIGHT, MIN_HEIGHT, NULL, NULL, NULL, NULL );
if ( !g_hWnd_property )
{
fail_type = 2;
goto CLEANUP;
}
// See if we have any command-line parameters
if ( lpCmdLine != NULL && lpCmdLine[ 0 ] != NULL )
{
// Count the number of parameters and split them into an array.
int argCount = 0;
LPWSTR *szArgList = CommandLineToArgvW( GetCommandLine(), &argCount );
if ( szArgList != NULL )
{
// The first parameter is the path to the executable. Ignore it.
if ( argCount > 1 )
{
// Allocate enough space to hold each parameter. They should all be full paths.
pathinfo *pi = ( pathinfo * )malloc( sizeof( pathinfo ) );
pi->type = 0;
pi->offset = 0;
pi->output_path = NULL;
pi->filepath = ( wchar_t * )malloc( sizeof( wchar_t ) * ( ( MAX_PATH * ( argCount - 1 ) ) + 1 ) );
wmemset( pi->filepath, 0, ( ( MAX_PATH * ( argCount - 1 ) ) + 1 ) );
cmd_line = 1; // Open the database(s) from the command-line.
int filepath_offset = 0;
for ( int i = 1; i < argCount; ++i )
{
int filepath_length = wcslen( szArgList[ i ] );
// See if it's an output parameter.
if ( filepath_length > 1 && szArgList[ i ][ 0 ] == L'-' && ( szArgList[ i ][ 1 ] == L'o' || szArgList[ i ][ 1 ] == L'O' ) )
{
// See if the next parameter exists. We'll assume it's the output directory.
if ( i + 1 < argCount )
{
if ( pi->output_path != NULL )
{
free( pi->output_path );
}
pi->output_path = _wcsdup( szArgList[ ++i ] );
pi->type = 0;
cmd_line = 2; // Save the database(s) from the command-line. Do not display the main window or any prompts.
}
}
else if ( filepath_length > 1 && szArgList[ i ][ 0 ] == L'-' && ( szArgList[ i ][ 1 ] == L'c' || szArgList[ i ][ 1 ] == L'C' ) )
{
// See if the next parameter exists. We'll assume it's the output directory.
if ( i + 1 < argCount )
{
if ( pi->output_path != NULL )
{
free( pi->output_path );
}
pi->output_path = _wcsdup( szArgList[ ++i ] );
pi->type = 1;
cmd_line = 2; // Save the database(s) from the command-line. Do not display the main window or any prompts.
}
}
else if ( filepath_length > 1 && szArgList[ i ][ 0 ] == L'-' && ( szArgList[ i ][ 1 ] == L'z' || szArgList[ i ][ 1 ] == L'Z' ) )
{
hide_blank_entries = true;
// Put a check next to the menu item. g_hMenu is created in g_hWnd_main.
CheckMenuItem( g_hMenu, MENU_HIDE_BLANK, MF_CHECKED );
}
else // Copy the paths into the NULL separated filepath.
{
// If the user typed a relative path, get the full path.
wchar_t full_path[ MAX_PATH ] = { 0 };
DWORD full_path_length = min( GetFullPathName( szArgList[ i ], MAX_PATH, full_path, NULL ), MAX_PATH );
wmemcpy_s( pi->filepath + filepath_offset, ( ( MAX_PATH * ( argCount - 1 ) ) + 1 ) - filepath_offset, full_path, full_path_length + 1 );
filepath_offset += ( full_path_length + 1 );
}
}
// Only read the database if there's a file to open.
if ( pi->filepath[ 0 ] != NULL )
{
// filepath will be freed in the thread.
CloseHandle( ( HANDLE )_beginthreadex( NULL, 0, &read_thumbcache, ( void * )pi, 0, NULL ) );
}
else
{
// Cleanup our parameters structure and exit the program.
free( pi->output_path );
free( pi->filepath );
free( pi );
cmd_line = -1;
SendMessage( g_hWnd_main, WM_DESTROY_ALT, 0, 0 );
}
}
// Free the parameter list.
LocalFree( szArgList );
}
}
if ( cmd_line == 0 || cmd_line == 1 )
{
ShowWindow( g_hWnd_main, SW_SHOW );
}
// Main message loop:
MSG msg;
while ( GetMessage( &msg, NULL, 0, 0 ) > 0 )
{
if ( g_hWnd_active == NULL || !IsDialogMessage( g_hWnd_active, &msg ) ) // Checks tab stops.
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}
CLEANUP:
// Destroy our icons.
DestroyIcon( hIcon_jpg );
DestroyIcon( hIcon_png );
DestroyIcon( hIcon_bmp );
// Delete our font.
DeleteObject( hFont );
// Delete our critical section.
DeleteCriticalSection( &pe_cs );
// Shutdown GDI+
Gdiplus::GdiplusShutdown( gdiplusToken );
// Unload the modules if they were initialized.
UnInitializeMsSrch();
UnInitializeMsSCB();
if ( fail_type == 1 )
{
MessageBoxA( NULL, "Call to RegisterClassEx failed!", PROGRAM_CAPTION_A, MB_ICONWARNING );
}
else if ( fail_type == 2 )
{
MessageBoxA( NULL, "Call to CreateWindow failed!", PROGRAM_CAPTION_A, MB_ICONWARNING );
}
return ( int )msg.wParam;
}
