typelibdump.cpp

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

	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.copy();
	}

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

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

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

	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 _bstr_t(_T("ITypeInfo::GetDocumentation() failed in TYPEDESCToString")).copy() ;
			}

			str = bstrName ;

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

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

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


typedef enum {
		typeUnknown         ,
		typeUnknown2        ,
		typeTypeLib         ,
		typeTypeLib2        ,
		typeTypeInfo        ,
		typeTypeInfo2       ,
		typeMethods         ,
		typeMethods2        ,
		typeProperties      ,
		typeProperties2     ,
		typeConstants       ,
		typeConstants2      ,
		typeImplTypes       ,
		typeImplTypes2      ,
		typeMethod          ,
		typeProperty        ,
		typeConstant        ,
		typeEnum            ,       // TKIND_ENUM
		typeRecord          ,       // TKIND_RECORD
		typeModule          ,       // TKIND_MODULE
		typeInterface       ,       // TKIND_INTERFACE
		typeDispinterface   ,       // TKIND_DISPATCH
		typeCoClass         ,       // TKIND_COCLASS
		typeAlias           ,       // TKIND_ALIAS
		typeUnion           ,       // TKIND_UNION
		typeEnums           ,
		typeRecords         ,
		typeModules         ,
		typeInterfaces      ,
		typeDispinterfaces  ,
		typeCoClasses       ,
		typeAliases         ,
		typeUnions          ,
	} ITEM_TYPE ;



#define MAX_NAMES   64     // max parameters to a function

//_COM_SMARTPTR_TYPEDEF(IMyInterface, __uuidof(IMyInterface));

BSTR GenerateStructEnumUnion(  ITypeInfo* pEnumTypeInfo, long indent )
{
	_bstr_t typeDefs;
	
	HRESULT hr = E_FAIL;

	_bstr_t indentStr = "";
	for ( int i=0;i<indent;i++){
		indentStr += "\t";
	}	
	
	TYPEATTR*   pEnumAttr = NULL ;
	hr = pEnumTypeInfo->GetTypeAttr( &pEnumAttr);
	
	switch ( pEnumAttr->typekind ) {
		case TKIND_ENUM:case TKIND_RECORD: case TKIND_UNION:{
			BSTR            bstrName = NULL ;
			BSTR            bstrDoc = NULL ;
			BSTR            bstrHelp = NULL ;
			DWORD           dwHelpID ;
			hr = pEnumTypeInfo->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp );
			
			switch ( pEnumAttr->typekind ) {
			case TKIND_RECORD: {
				typeDefs += indentStr;
				typeDefs += "struct ";
							   }
				break;
				
			case TKIND_UNION: {
				typeDefs += indentStr;
				typeDefs += "union ";
							  }
				break;
				
			case TKIND_ENUM: {
				typeDefs += indentStr;
				typeDefs += "enum ";
							 }
				break;
			}
			typeDefs += bstrName;
			
			SysFreeString(bstrName) ;
			SysFreeString( bstrDoc ) ;
			SysFreeString( bstrHelp ) ;
			
			typeDefs += " {\n";
			if ( (pEnumAttr->typekind == TKIND_RECORD) || (pEnumAttr->typekind == TKIND_UNION) ) {
				for (UINT ei = 0 ; ei < pEnumAttr->cVars ; ei++) {
					VARDESC*    pvardesc = NULL ;
					pEnumTypeInfo->GetVarDesc( ei, &pvardesc );
					pEnumTypeInfo->GetDocumentation( pvardesc->memid, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp );
					BSTR            rgbstrNames[1] ;
					UINT enum_cNames = 0;
					pEnumTypeInfo->GetNames( pvardesc->memid, rgbstrNames, 1, (UINT FAR*)&enum_cNames );
					_bstr_t str = TYPEDESCtoString( pEnumTypeInfo, &pvardesc->elemdescVar.tdesc );
					
					SysFreeString(bstrName) ;
					SysFreeString( bstrDoc ) ;
					SysFreeString( bstrHelp ) ;
					
					typeDefs += indentStr;
					typeDefs += "\t";
					typeDefs += str;
					typeDefs += " ";
					typeDefs += rgbstrNames[0];
					typeDefs += ";\n";
					
					SysFreeString(rgbstrNames[0]) ;
				}
			}
			else if ((pEnumAttr->typekind == TKIND_ENUM)) {
				for (UINT ei = 0 ; ei < pEnumAttr->cVars ; ei++) {
					VARDESC*    pvardesc = NULL ;
					hr = pEnumTypeInfo->GetVarDesc( ei, &pvardesc );
					_bstr_t str = TYPEDESCtoString( pEnumTypeInfo, &pvardesc->elemdescVar.tdesc );
					VARIANT varValue ;
					VariantInit( &varValue ) ;
					hr = VariantChangeType( &varValue, pvardesc->lpvarValue, 0, VT_BSTR );
					if ( FAILED(hr) ) {
						if (pvardesc->lpvarValue->vt == VT_ERROR || pvardesc->lpvarValue->vt == VT_HRESULT)
						{
							varValue.vt = VT_BSTR ;
							varValue.bstrVal = _bstr_t(_GetScodeString(pvardesc->lpvarValue->scode)).copy() ;
							hr = S_OK ;
						}
					}
					BSTR            rgbstrNames[1] ;
					UINT enum_cNames = 0;
					pEnumTypeInfo->GetNames( pvardesc->memid, rgbstrNames, 1, (UINT FAR*)&enum_cNames );
					typeDefs += indentStr;
					typeDefs += "\t ";
					//enumStr += str;
					//enumStr += " ";
					typeDefs += rgbstrNames[0];
					typeDefs += " = ";
					if (pvardesc->lpvarValue->vt == VT_BSTR) {
						typeDefs += "\"";
						typeDefs += varValue.bstrVal;
						typeDefs += "\"";	
					}
					else {
						typeDefs += varValue.bstrVal;
					}
					if ( ei == (UINT)(pEnumAttr->cVars-1) ) {
						typeDefs += "\n";
					}
					else {
						typeDefs += ",\n";
					}
					SysFreeString(rgbstrNames[0]);
				}
			}
			typeDefs += indentStr;
			typeDefs += "};\n";
			
			//printf( "typedef found: \n%s\n", (char*)enumStr );
		}
		break;
	}
	pEnumTypeInfo->ReleaseTypeAttr( pEnumAttr );
			
	return typeDefs.copy();
}

BSTR GenerateClassTypeDefs( ITypeLib* pTypeLib, long indent )
{
	_bstr_t typeDefs;
	
	HRESULT hr = E_FAIL;

	_bstr_t indentStr = "";
	for ( int i=0;i<indent;i++){
		indentStr += "\t";
	}
	int tic = pTypeLib->GetTypeInfoCount();
	for (int ti=0;ti<(int)tic;ti++) {
		ITypeInfo* pEnumTypeInfo = NULL;
		hr = pTypeLib->GetTypeInfo( ti, &pEnumTypeInfo );
		if ( SUCCEEDED(hr) ) {
			TYPEATTR*   pEnumAttr = NULL ;
			hr = pEnumTypeInfo->GetTypeAttr( &pEnumAttr);
			
			switch ( pEnumAttr->typekind ) {
				case TKIND_ENUM:case TKIND_RECORD: case TKIND_UNION:{
					
					typeDefs += GenerateStructEnumUnion( pEnumTypeInfo, indent );

				}
				break;

				case TKIND_ALIAS:{
					BSTR            bstrName = NULL ;
					BSTR            bstrDoc = NULL ;
					BSTR            bstrHelp = NULL ;
					DWORD           dwHelpID ;
					hr = pEnumTypeInfo->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp );

					typeDefs += "typedef ";
					typeDefs += TYPEDESCtoString( pEnumTypeInfo, &pEnumAttr->tdescAlias );
					typeDefs += " ";
					typeDefs += bstrName;
					typeDefs += ";\n\n";
					//bstrName;

					SysFreeString(bstrName) ;
					SysFreeString( bstrDoc ) ;
					SysFreeString( bstrHelp ) ;
				}
				break;
			}
			pEnumTypeInfo->ReleaseTypeAttr( pEnumAttr );
			pEnumTypeInfo->Release();
		}
	}
			
	return typeDefs.copy();
}

BSTR GenerateClassMethod( ITypeInfo* pMethodTypeInfo, long methodID )
{
	_bstr_t method;
	
	FUNCDESC*   pfuncdesc = NULL ;
	BSTR            rgbstrNames[MAX_NAMES] ;
	BSTR            bstrName = NULL ;
	BSTR            bstrDoc = NULL ;
	BSTR            bstrHelp = NULL ;
	DWORD           dwHelpID ;
	for (UINT ui = 0 ; ui < MAX_NAMES ; ui++)
		rgbstrNames[ui] = NULL ;

	HRESULT hr = pMethodTypeInfo->GetFuncDesc( methodID, &pfuncdesc );

	hr = pMethodTypeInfo->GetDocumentation( pfuncdesc->memid, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp );
	UINT cNames = 0 ;
	hr = pMethodTypeInfo->GetNames( pfuncdesc->memid, rgbstrNames, MAX_NAMES, &cNames );
	
	//if ((int)cNames < pfuncdesc->cParams + 1)
	//{
	//	rgbstrNames[cNames] = ::SysAllocString(OLESTR("rhs")) ;
	//	cNames++ ;
	//}
	//assert((int)cNames == pfuncdesc->cParams+1) ;
	
	
	method += TYPEDESCtoString( pMethodTypeInfo, &pfuncdesc->elemdescFunc.tdesc );
	method += " ";
	
	if (pfuncdesc->invkind & INVOKE_PROPERTYGET) {
		cNames --;
		method += "get_";
	}
	else if ((pfuncdesc->invkind & INVOKE_PROPERTYPUT) || (pfuncdesc->invkind & INVOKE_PROPERTYPUTREF)) {
		method += "set_";
	}
	method += rgbstrNames[0];
	method += "( ";
	
	for ( int p=0;p<pfuncdesc->cParams;p++) {
		bool paramIsPointer = false;
		if ( pfuncdesc->lprgelemdescParam ) {
			if ( pfuncdesc->lprgelemdescParam[p].idldesc.wIDLFlags ) {
				if (pfuncdesc->lprgelemdescParam[p].idldesc.wIDLFlags & IDLFLAG_FOUT) {
					paramIsPointer = true;
				}
				if (pfuncdesc->lprgelemdescParam[p].idldesc.wIDLFlags & IDLFLAG_FRETVAL) {
					paramIsPointer = true;
				}
				
				if ((pfuncdesc->lprgelemdescParam[p].tdesc.vt & 0x0FFF) == VT_CARRAY) {
					_bstr_t val = TYPEDESCtoString( pMethodTypeInfo, &pfuncdesc->lprgelemdescParam[p].tdesc.lpadesc->tdescElem );
				}
				else {
					_bstr_t type = TYPEDESCtoString( pMethodTypeInfo, &pfuncdesc->lprgelemdescParam[p].tdesc );
					_bstr_t paramName = rgbstrNames[p+1];									
					
					method += type;
					method += " ";
					if ( paramName.length() == 0 ) {
						paramName = "Val";
					}
					method += paramName;
					
					if ( p!=(pfuncdesc->cParams-1) ) {
						method += ", ";
					}
				}
			}
		}
	}
	method += " ); //";
	TCHAR methIDStr[256];
	memset( methIDStr, 0, 256 );
	sprintf( methIDStr, "(id[%d])", pfuncdesc->memid );
	method += methIDStr;
	
	SysFreeString(bstrName) ;
	SysFreeString( bstrDoc ) ;
	SysFreeString( bstrHelp ) ;

	for (ui = 0 ; ui < MAX_NAMES ; ui++) {
		if (rgbstrNames[ui]) {
			SysFreeString(rgbstrNames[ui]) ;
		}
	}
	pMethodTypeInfo->ReleaseFuncDesc( pfuncdesc ) ;
	
	return method.copy();
}


BSTR GenerateClassHeaderFromCOMCLSID( const CLSID& clsid )
{
	_bstr_t body;

	_bstr_t className;
	_bstr_t intefaceName;

	body += "class ";
	body += className;
	body += "  {  \n";
	body += "public:\n";
	body += "\t";
	body += className;
	body += " ();\n\n";
	body += "\tvirtual ~";
	body += className;
	body += " ();\n\n";
	body += "\n\t//auto generated methods for interface ";
	body += intefaceName;
	body += "\n\n";
	
	HRESULT hr = E_FAIL;

	IUnknown* pIUnknown = NULL;
	hr = CoCreateInstance( clsid, 0, CLSCTX_INPROC_SERVER, IID_IUnknown,