Method WritePropertyData

source/Debugger.cpp:1271–1360

}

int Debugger::WritePropertyData(LPCTSTR aData, size_t aDataSize, int aMaxEncodedSize)
// Accepts a "native" string, converts it to UTF-8, base64-encodes it and writes
// the end of the property's size attribute followed by the base64-encoded data.
{
	int err;
	
#ifdef UNICODE
	LPCWSTR utf16_value = aData;
	size_t total_utf16_size = aDataSize;
#else
	// ANSI mode.  For simplicity, convert the entire data to UTF-16 rather than attempting to
	// calculate how much ANSI text will produce the right number of UTF-8 bytes (since UTF-16
	// is needed as an intermediate step anyway).  This would fail if the string length exceeds
	// INT_MAX, but that would only matter if we built ANSI for x64 (and we don't).
	CStringWCharFromChar utf16_buf(aData, aDataSize);
	LPCWSTR utf16_value = utf16_buf.GetString();
	size_t total_utf16_size = utf16_buf.GetLength();
	if (!total_utf16_size && aDataSize) // Conversion failed (too large?)
		return DEBUGGER_E_INTERNAL_ERROR;
#endif
	
	// The spec says: "The IDE should not read more data than the length defined in the packet
	// header.  The IDE can determine if there is more data by using the property data length
	// information."  This has two implications:
	//  1) The size attribute should represent the total size, not the amount of data actually
	//     returned (when limited by aMaxEncodedSize).  This is more useful anyway.
	//  2) Since the data is encoded as UTF-8, the size attribute must be a UTF-8 byte count
	//     for any comparison by the IDE to give the correct result.

	// According to the spec, -m 0 should mean "unlimited".
	if (!aMaxEncodedSize)
		aMaxEncodedSize = INT_MAX;
	
	// Calculate:
	//  - the total size in terms of UTF-8 bytes (even if that exceeds INT_MAX).
	size_t total_utf8_size = 0;
	//  - the maximum number of wide chars to convert, taking aMaxEncodedSize into account.
	int utf16_size = (int)total_utf16_size;
	//  - the required buffer size for conversion, in bytes.
	int utf8_size = -1;

	for (size_t i = 0; i < total_utf16_size; ++i)
	{
		wchar_t wc = utf16_value[i];
		
		int char_size;
		if (wc <= 0x007F)
			char_size = 1;
		else if (wc <= 0x07FF)
			char_size = 2;
		else if (IS_SURROGATE_PAIR(wc, utf16_value[i+1]))
			char_size = 4;
		else
			char_size = 3;
		
		total_utf8_size += char_size;

		if (total_utf8_size > (size_t)aMaxEncodedSize)