util.cpp

来自「这是VCF框架的代码」· C++ 代码 · 共 717 行 · 第 1/2 页

		MAKE_RANGE_ENTRY(INPLACE_E),
		MAKE_RANGE_ENTRY(INPLACE_S),
		MAKE_RANGE_ENTRY(MARSHAL_E),
		MAKE_RANGE_ENTRY(MARSHAL_S),
		MAKE_RANGE_ENTRY(MK_E),
		MAKE_RANGE_ENTRY(MK_S),
		MAKE_RANGE_ENTRY(OLEOBJ_E),
		MAKE_RANGE_ENTRY(OLEOBJ_S),
		MAKE_RANGE_ENTRY(OLE_E),
		MAKE_RANGE_ENTRY(OLE_S),
		MAKE_RANGE_ENTRY(REGDB_E),
		MAKE_RANGE_ENTRY(REGDB_S),
		MAKE_RANGE_ENTRY(VIEW_E),
		MAKE_RANGE_ENTRY(VIEW_S),
	};
	#undef MAKE_RANGE_ENTRY

	// look for it in the table
	for (int i = 0; i < _countof(scRangeTable); i++)
	{
		if (sc >= scRangeTable[i].scFirst && sc <= scRangeTable[i].scLast)
			return scRangeTable[i].lpszName;
	}
	return NULL;    // not found
}

LPCTSTR AFXAPI _GetSeverityString(SCODE sc)
{
	static const TCHAR* rgszSEVERITY[] =
	{
		_T("SEVERITY_SUCCESS"),
		_T("SEVERITY_ERROR"),
	};
	return rgszSEVERITY[SCODE_SEVERITY(sc)];
}

LPCTSTR AFXAPI _GetFacilityString(SCODE sc)
{
	static const TCHAR* rgszFACILITY[] =
	{
		_T("FACILITY_NULL"),
		_T("FACILITY_RPC"),
		_T("FACILITY_DISPATCH"),
		_T("FACILITY_STORAGE"),
		_T("FACILITY_ITF"),
		_T("FACILITY_0x05"),
		_T("FACILITY_0x06"),
		_T("FACILITY_WIN32"),
		_T("FACILITY_WINDOWS"),
	};
	if (SCODE_FACILITY(sc) >= _countof(rgszFACILITY))
		return _T("<Unknown Facility>");

	return rgszFACILITY[SCODE_FACILITY(sc)];
}

LPCTSTR AFXAPI _GetFullScodeString(SCODE sc)
{
	static TCHAR szBuf[128];
	LPCTSTR lpsz;
	if ((lpsz = _GetScodeString(sc)) != NULL)
	{
		// found exact match
		wsprintf(szBuf, _T("%s ($%08lX)"), lpsz, sc);
	}
	else if ((lpsz = _GetScodeRangeString(sc)) != NULL)
	{
		// found suitable range
		wsprintf(szBuf, _T("range: %s ($%08lX)"), lpsz, sc);
	}
	else
	{
		// not found at all -- split it up into its parts
		wsprintf(szBuf, _T("severity: %s, facility: %s ($%08lX)"),
			_GetSeverityString(sc), _GetFacilityString(sc), sc);
	}
	return szBuf;
}


LPTSTR HRtoString( HRESULT hr )
{
	SCODE   sc ;
	sc = GetScode( hr ) ;

#ifdef FORMATMSG
	LPVOID lpMessageBuffer ;
	if (FormatMessage(
		  FORMAT_MESSAGE_ALLOCATE_BUFFER |
		  FORMAT_MESSAGE_FROM_SYSTEM,
		  NULL,
		  sc,
		  MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
		  (LPTSTR) &lpMessageBuffer,
		  0,
		  NULL ))
	{
		wsprintf( sz, _T( "%s (0x%lx)" ), (LPTSTR)lpMessageBuffer, sc);
		LocalFree(lpMessageBuffer) ;
	}
	else
	{
		wsprintf( sz, _T( "Unknown Scode (0x%lx)" ), sc);
	}


#endif // !FORMATMSG

	return (LPTSTR)_GetFullScodeString(sc) ;
}

#include <ctype.h>
// Very useful API that parses a LONG out of a string, updating
// the string pointer before it returns.
//
LONG WINAPI ParseOffNumber( LPTSTR FAR *lplp, LPINT lpConv )
{
	LPTSTR lp = *lplp;
	LONG  lValue=0;
	int   sign=1;

	while( isspace(*lp) )
		lp++;
	if( *lp=='-' )
	{
		sign = -1;
		lp++;
	}
	if (*lp=='\0')
	{
		*lpConv = FALSE;
		return 0L;
	}

	// Is it a decimal number
	#ifdef UNICODE
	if( _wcsnicmp( lp, (LPTSTR)_T("0x"),2) )
	#else
	#ifdef WIN32
	if( strnicmp( lp, (LPTSTR)_T("0x"),2) )
	#else
	if( _fstrnicmp( lp, (LPTSTR)_T("0x"),2) )
	#endif
	#endif
	{

		while( isdigit(*lp) )
		{
			lValue *= 10;
			lValue += (*lp - (TCHAR)'0');
			lp++;
		}
	}
	else
	{
		lp+=2;

		while( isxdigit(*lp) )
		{
			lValue *= 16;
			if( isdigit(*lp) )
				lValue += (*lp - (TCHAR)'0');
			else
				lValue += (toupper(*lp) - (TCHAR)'A' + 10);
			lp++;
		}
	}
	while( isspace(*lp) )
		lp++;

	lValue *= (long)sign;

	if (*lp==(TCHAR)',')
	{
		lp++;
		while( isspace(*lp) )
			lp++;
		*lplp = lp;
		if (lpConv)
			*lpConv = (int)TRUE;
	}
	else
	{
		*lplp = lp;
		if (lpConv)
			*lpConv = (int)(*lp=='\0');
	}
	return lValue;

} //*** ParseOffNumber

static TCHAR* BASED_CODE g_rgszVT[] =
{
	_T("void"),             //VT_EMPTY           = 0,   /* [V]   [P]  nothing                     */
	_T("null"),             //VT_NULL            = 1,   /* [V]        SQL style Null              */
	_T("short"),            //VT_I2              = 2,   /* [V][T][P]  2 byte signed int           */
	_T("long"),             //VT_I4              = 3,   /* [V][T][P]  4 byte signed int           */
	_T("single"),           //VT_R4              = 4,   /* [V][T][P]  4 byte real                 */
	_T("double"),           //VT_R8              = 5,   /* [V][T][P]  8 byte real                 */
	_T("CURRENCY"),         //VT_CY              = 6,   /* [V][T][P]  currency                    */
	_T("DATE"),             //VT_DATE            = 7,   /* [V][T][P]  date                        */
	_T("BSTR"),             //VT_BSTR            = 8,   /* [V][T][P]  binary string               */
	_T("IDispatch*"),       //VT_DISPATCH        = 9,   /* [V][T]     IDispatch FAR*              */
	_T("SCODE"),            //VT_ERROR           = 10,  /* [V][T]     SCODE                       */
	_T("boolean"),          //VT_BOOL            = 11,  /* [V][T][P]  True=-1, False=0            */
	_T("VARIANT"),          //VT_VARIANT         = 12,  /* [V][T][P]  VARIANT FAR*                */
	_T("IUnknown*"),        //VT_UNKNOWN         = 13,  /* [V][T]     IUnknown FAR*               */
	_T("wchar_t"),          //VT_WBSTR           = 14,  /* [V][T]     wide binary string          */
	_T(""),                 //                   = 15,
	_T("char"),             //VT_I1              = 16,  /*    [T]     signed char                 */
	_T("unsigned char"),             //VT_UI1             = 17,  /*    [T]     unsigned char               */
	_T("unsigned short"),           //VT_UI2             = 18,  /*    [T]     unsigned short              */
	_T("unsigned long"),            //VT_UI4             = 19,  /*    [T]     unsigned short              */
	_T("int64"),            //VT_I8              = 20,  /*    [T][P]  signed 64-bit int           */
	_T("uint64"),           //VT_UI8             = 21,  /*    [T]     unsigned 64-bit int         */
	_T("int"),              //VT_INT             = 22,  /*    [T]     signed machine int          */
	_T("unsigned int"),             //VT_UINT            = 23,  /*    [T]     unsigned machine int        */
	_T("void"),             //VT_VOID            = 24,  /*    [T]     C style void                */
	_T("HRESULT"),          //VT_HRESULT         = 25,  /*    [T]                                 */
	_T("PTR"),              //VT_PTR             = 26,  /*    [T]     pointer type                */
	_T("SAFEARRAY"),        //VT_SAFEARRAY       = 27,  /*    [T]     (use VT_ARRAY in VARIANT)   */
	_T("CARRAY"),           //VT_CARRAY          = 28,  /*    [T]     C style array               */
	_T("USERDEFINED"),      //VT_USERDEFINED     = 29,  /*    [T]     user defined type         */
	_T("LPSTR"),            //VT_LPSTR           = 30,  /*    [T][P]  null terminated string      */
	_T("LPWSTR"),           //VT_LPWSTR          = 31,  /*    [T][P]  wide null terminated string */
	_T(""),                 //                   = 32,
	_T(""),                 //                   = 33,
	_T(""),                 //                   = 34,
	_T(""),                 //                   = 35,
	_T(""),                 //                   = 36,
	_T(""),                 //                   = 37,
	_T(""),                 //                   = 38,
	_T(""),                 //                   = 39,
	_T(""),                 //                   = 40,
	_T(""),                 //                   = 41,
	_T(""),                 //                   = 42,
	_T(""),                 //                   = 43,
	_T(""),                 //                   = 44,
	_T(""),                 //                   = 45,
	_T(""),                 //                   = 46,
	_T(""),                 //                   = 47,
	_T(""),                 //                   = 48,
	_T(""),                 //                   = 49,
	_T(""),                 //                   = 50,
	_T(""),                 //                   = 51,
	_T(""),                 //                   = 52,
	_T(""),                 //                   = 53,
	_T(""),                 //                   = 54,
	_T(""),                 //                   = 55,
	_T(""),                 //                   = 56,
	_T(""),                 //                   = 57,
	_T(""),                 //                   = 58,
	_T(""),                 //                   = 59,
	_T(""),                 //                   = 60,
	_T(""),                 //                   = 61,
	_T(""),                 //                   = 62,
	_T(""),                 //                   = 63,
	_T("FILETIME"),         //VT_FILETIME        = 64,  /*       [P]  FILETIME                    */
	_T("BLOB"),             //VT_BLOB            = 65,  /*       [P]  Length prefixed bytes       */
	_T("STREAM"),           //VT_STREAM          = 66,  /*       [P]  Name of the stream follows  */
	_T("STORAGE"),          //VT_STORAGE         = 67,  /*       [P]  Name of the storage follows */
	_T("STREAMED_OBJECT"),  //VT_STREAMED_OBJECT = 68,  /*       [P]  Stream contains an object   */
	_T("STORED_OBJECT"),    //VT_STORED_OBJECT   = 69,  /*       [P]  Storage contains an object  */
	_T("BLOB_OBJECT"),      //VT_BLOB_OBJECT     = 70,  /*       [P]  Blob contains an object     */
	_T("CF"),               //VT_CF              = 71,  /*       [P]  Clipboard format            */
	_T("CLSID"),            //VT_CLSID           = 72   /*       [P]  A Class ID                  */
};

CString VTtoString( VARTYPE vt )
{
	CString str ;
	vt &= ~0xF000 ;
	if (vt <= VT_CLSID)
	   str = g_rgszVT[vt]  ;
	else
	   str = "BAD VARTYPE" ;

	return str ;
}
CString TYPEDESCtoString( ITypeInfo* pti, TYPEDESC* ptdesc )
{
	CString str ;

	if (ptdesc->vt == VT_PTR)
	{
		// ptdesc->lptdesc points to a TYPEDESC that specifies the thing pointed to

		str = TYPEDESCtoString( pti, ptdesc->lptdesc ) ;
		str += "*" ;
		return str.AllocSysString() ;
	}

	if ((ptdesc->vt & 0x0FFF) == VT_CARRAY)
	{
		// ptdesc->lpadesc points to an ARRAYDESC
		str = TYPEDESCtoString( pti, &ptdesc->lpadesc->tdescElem ) ;

		// Allocate cDims * lstrlen("[123456]")
		CString strTemp ;
		for (USHORT n = 0 ; n < ptdesc->lpadesc->cDims ; n++)
		{
			strTemp.Format( _T("[%d]"), ptdesc->lpadesc->rgbounds[n].cElements ) ;
			str += strTemp ;
		}
		return str ;
	}

	if ((ptdesc->vt & 0x0FFF) == VT_SAFEARRAY)
	{
		str = "SAFEARRAY(" + TYPEDESCtoString( pti, ptdesc->lptdesc ) + ")" ;
		return str ;
	}

	if (ptdesc->vt == VT_USERDEFINED)
	{
		// Use ptdesc->hreftype and pti->GetRefTypeInfo
		//
		ASSERT(pti) ;
		ITypeInfo* ptiRefType = NULL ;
		HRESULT hr = pti->GetRefTypeInfo( ptdesc->hreftype, &ptiRefType ) ;
		if (SUCCEEDED(hr))
		{
			BSTR            bstrName = NULL ;
			BSTR            bstrDoc = NULL ;
			BSTR            bstrHelp = NULL ;
			DWORD           dwHelpID ;
			hr = ptiRefType->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp ) ;
			if (FAILED(hr))
			{
				#ifdef _DEBUG
				ErrorMessage(_T("ITypeInfo::GetDocumentation() failed"), hr ) ;
				#endif
				return _T("ITypeInfo::GetDocumentation() failed in TYPEDESCToString") ;
			}

			str = bstrName ;

			SysFreeString(bstrName) ;
			SysFreeString( bstrDoc ) ;
			SysFreeString( bstrHelp ) ;

			ptiRefType->Release() ;
		}
		else
		{
			#ifdef _DEBUG
			ErrorMessage( _T("GetRefTypeInfo failed in TYPEDESCToString"), hr ) ;
			#endif
			return _T("<GetRefTypeInfo failed>") ;
		}

		return str ;
	}
	return VTtoString( ptdesc->vt );
}