int test_unicode_uppercasing(BYTE* lower, BYTE* upper)
{
WCHAR* lowerW = NULL;
int lowerLength;
WCHAR* upperW = NULL;
int upperLength;
lowerLength = ConvertToUnicode(CP_UTF8, 0, (LPSTR) lower, -1, &lowerW, 0);
upperLength = ConvertToUnicode(CP_UTF8, 0, (LPSTR) upper, -1, &upperW, 0);
CharUpperBuffW(lowerW, lowerLength);
if (_wcscmp(lowerW, upperW) != 0)
{
printf("Lowercase String:\n");
string_hexdump((BYTE*) lowerW, lowerLength * 2);
printf("Uppercase String:\n");
string_hexdump((BYTE*) upperW, upperLength * 2);
return -1;
}
free(lowerW);
free(upperW);
return 0;
}
// Renames a previously saved persisted watch list
HRESULT WatchCmd::RenameList(__in_z WCHAR* pOldName, __in_z WCHAR* pNewName)
{
if(_wcscmp(pOldName, pNewName)==0)
return S_OK;
PersistList** ppList = &pPersistListHead;
while(*ppList != NULL)
{
if(_wcscmp((*ppList)->pName, pOldName) == 0)
{
PersistList* pListToChangeName = *ppList;
RemoveList(pNewName);
wcsncpy_s(pListToChangeName->pName, MAX_EXPRESSION, pNewName, _TRUNCATE);
return S_OK;
}
ppList = &((*ppList)->pNext);
}
return S_FALSE;
}
COMMAND_LINE_ARGUMENT_W* CommandLineFindArgumentW(COMMAND_LINE_ARGUMENT_W* options, LPCWSTR Name)
{
int i;
for (i = 0; options[i].Name != NULL; i++)
{
if (_wcscmp(options[i].Name, Name) == 0)
return &options[i];
if (options[i].Alias != NULL)
{
if (_wcscmp(options[i].Alias, Name) == 0)
return &options[i];
}
}
return NULL;
}
// Deletes an persisted watch list by name
HRESULT WatchCmd::RemoveList(__in_z WCHAR* pListName)
{
PersistList** ppList = &pPersistListHead;
while(*ppList != NULL)
{
if(_wcscmp((*ppList)->pName, pListName) == 0)
{
PersistList* toDelete = *ppList;
*ppList = (*ppList)->pNext;
delete toDelete;
return S_OK;
}
ppList = &((*ppList)->pNext);
}
return S_FALSE;
}
bool MethodTable::IsZombie(TADDR addr)
{
// Zombie objects are objects that reside in an unloaded AppDomain.
MethodTable mt = addr;
return _wcscmp(mt.GetName(), W("<Unloaded Type>")) == 0;
}
// Evaluates and prints a tree version of the active watch list
// The tree will be expanded along the nodes in expansionPath
// Optionally the list is filtered to only show differences from pFilterName (the name of a persisted watch list)
HRESULT WatchCmd::Print(int expansionIndex, __in_z WCHAR* expansionPath, __in_z WCHAR* pFilterName)
{
HRESULT Status = S_OK;
INIT_API_EE();
INIT_API_DAC();
EnableDMLHolder dmlHolder(TRUE);
IfFailRet(InitCorDebugInterface());
PersistList* pFilterList = NULL;
if(pFilterName != NULL)
{
pFilterList = pPersistListHead;
while(pFilterList != NULL)
{
if(_wcscmp(pFilterList->pName, pFilterName)==0)
break;
pFilterList = pFilterList->pNext;
}
}
PersistWatchExpression* pHeadFilterExpr = (pFilterList != NULL) ? pFilterList->pHeadExpr : NULL;
WatchExpression* pExpression = pExpressionListHead;
int index = 1;
while(pExpression != NULL)
{
ExpressionNode* pResult = NULL;
if(FAILED(Status = ExpressionNode::CreateExpressionNode(pExpression->pExpression, &pResult)))
{
ExtOut(" %d) Error: HRESULT 0x%x while evaluating expression \'%S\'", index, Status, pExpression->pExpression);
}
else
{
//check for matching absolute expression
PersistWatchExpression* pCurFilterExpr = pHeadFilterExpr;
while(pCurFilterExpr != NULL)
{
if(_wcscmp(pCurFilterExpr->pExpression, pResult->GetAbsoluteExpression())==0)
break;
pCurFilterExpr = pCurFilterExpr->pNext;
}
// check for matching persist evaluation on the matching expression
BOOL print = TRUE;
if(pCurFilterExpr != NULL)
{
WCHAR pCurPersistResult[MAX_EXPRESSION];
FormatPersistResult(pCurPersistResult, MAX_EXPRESSION, pResult);
if(_wcscmp(pCurPersistResult, pCurFilterExpr->pPersistResult)==0)
{
print = FALSE;
}
}
//expand and print
if(print)
{
if(index == expansionIndex)
pResult->Expand(expansionPath);
PrintCallbackData data;
data.index = index;
WCHAR pCommand[MAX_EXPRESSION];
swprintf_s(pCommand, MAX_EXPRESSION, L"!watch -expand %d", index);
data.pCommand = pCommand;
pResult->DFSVisit(EvalPrintCallback, (VOID*)&data);
}
delete pResult;
}
pExpression = pExpression->pNext;
index++;
}
return Status;
}
int convert_utf8_to_utf16(BYTE* lpMultiByteStr, BYTE* expected_lpWideCharStr, int expected_cchWideChar)
{
int length;
int cbMultiByte;
int cchWideChar;
LPWSTR lpWideCharStr;
cbMultiByte = strlen((char*) lpMultiByteStr);
cchWideChar = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR) lpMultiByteStr, -1, NULL, 0);
printf("MultiByteToWideChar Input UTF8 String:\n");
string_hexdump(lpMultiByteStr, cbMultiByte + 1);
printf("MultiByteToWideChar required cchWideChar: %d\n", cchWideChar);
if (cchWideChar != expected_cchWideChar)
{
printf("MultiByteToWideChar unexpected cchWideChar: actual: %d expected: %d\n",
cchWideChar, expected_cchWideChar);
return -1;
}
lpWideCharStr = (LPWSTR) malloc(cchWideChar * sizeof(WCHAR));
if (!lpWideCharStr)
{
printf("MultiByteToWideChar: unable to allocate memory for test\n");
return -1;
}
lpWideCharStr[cchWideChar - 1] = 0xFFFF; /* should be overwritten if null terminator is inserted properly */
length = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR) lpMultiByteStr, cbMultiByte + 1, lpWideCharStr, cchWideChar);
printf("MultiByteToWideChar converted length (WCHAR): %d\n", length);
if (!length)
{
DWORD error = GetLastError();
printf("MultiByteToWideChar error: 0x%08X\n", error);
return -1;
}
if (length != expected_cchWideChar)
{
printf("MultiByteToWideChar unexpected converted length (WCHAR): actual: %d expected: %d\n",
length, expected_cchWideChar);
return -1;
}
if (_wcscmp(lpWideCharStr, (WCHAR*) expected_lpWideCharStr) != 0)
{
printf("MultiByteToWideChar unexpected string:\n");
printf("UTF8 String:\n");
string_hexdump(lpMultiByteStr, cbMultiByte + 1);
printf("UTF16 String (actual):\n");
string_hexdump((BYTE*) lpWideCharStr, length * sizeof(WCHAR));
printf("UTF16 String (expected):\n");
string_hexdump((BYTE*) expected_lpWideCharStr, expected_cchWideChar * sizeof(WCHAR));
return -1;
}
printf("MultiByteToWideChar Output UTF16 String:\n");
string_hexdump((BYTE*) lpWideCharStr, length * sizeof(WCHAR));
printf("\n");
free(lpWideCharStr);
return length;
}
