typelibdump.cpp

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

		                          (void**) &pIUnknown );

	IDispatch* pIDisp = NULL;
	hr = pIUnknown->QueryInterface( IID_IDispatch, (void**)&pIDisp );
	if ( SUCCEEDED(hr) ) {
		ITypeInfo* pTypeInfo = NULL;
		ITypeLib* pTypeLib = NULL;	
		UINT hasInfo = 0;
		hr = pIDisp->GetTypeInfoCount( &hasInfo );
		if ( hasInfo ) {
			hr = pIDisp->GetTypeInfo( 0, 0, &pTypeInfo );
			if ( SUCCEEDED(hr) ) {
				UINT index = 0;
				hr = pTypeInfo->GetContainingTypeLib( &pTypeLib, &index );
				pTypeInfo->Release();
				pTypeInfo = NULL;

				if ( SUCCEEDED(hr) ) {
					
					hr = pTypeLib->GetTypeInfoOfGuid( clsid, &pTypeInfo );	

					_bstr_t typeDefs = GenerateClassTypeDefs( pTypeLib, 1 );

					body += typeDefs;
					body += "\n\n";

					TYPEATTR*   pattr = NULL ;
					hr = pTypeInfo->GetTypeAttr( &pattr);
					BSTR            bstrName = NULL ;
					BSTR            bstrDoc = NULL ;
					BSTR            bstrHelp = NULL ;
					DWORD           dwHelpID ;
					ITypeInfo*      ptiImpl = NULL ;
					TYPEATTR*       pattrImpl = NULL ;
					pTypeInfo->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp );
					for (UINT n = 0 ; n < pattr->cImplTypes ; n++)	{
						int impltype = 0;
						HREFTYPE href = NULL ;
						hr = pTypeInfo->GetImplTypeFlags( n, &impltype );
						hr = pTypeInfo->GetRefTypeOfImplType(n, &href);
						hr = pTypeInfo->GetRefTypeInfo( href, &ptiImpl );
						hr = ptiImpl->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp );
						_bstr_t interfaceName = bstrName;

						//printf( "Interface \"%s\"\n", (char*)interfaceName);

						hr = ptiImpl->GetTypeAttr( &pattrImpl);
						switch ( pattrImpl->typekind ) {
							case TKIND_ENUM:
							case TKIND_RECORD:
							case TKIND_UNION:
							case TKIND_ALIAS: {
								
							}
							break;

							case TKIND_INTERFACE: {
								OLECHAR guidStr[256];
								StringFromGUID2( pattrImpl->guid, guidStr, 256 );
								body += "\t// generated methods for interface ";
								body += interfaceName;
								body += " (guid: ";
								body += guidStr;
								body += ")\n";
								for (UINT i = 0 ; i < pattrImpl->cFuncs ; i++)	{
									
									body += "\t";
									body += GenerateClassMethod( ptiImpl, i );
									body += "\n\n";
								}
							}
							break;

							case TKIND_DISPATCH: {
								OLECHAR guidStr[256];
								StringFromGUID2( pattrImpl->guid, guidStr, 256 );
								body += "\t// generated methods for dispatch interface ";
								body += interfaceName;
								body += " (guid: ";
								body += guidStr;
								body += ")\n";
								for (UINT i = 0 ; i < pattrImpl->cFuncs ; i++)	{
									
									body += "\t";
									body += GenerateClassMethod( ptiImpl, i );
									body += "\n\n";
								}
							}
							break;
						}
						ptiImpl->Release();
					}
					pTypeInfo->ReleaseTypeAttr( pattr );
					pTypeInfo->Release();
				}
			}
		}
		pIDisp->Release();
	}

	pIUnknown->Release();

	body += "};\n";

	return body.copy();
}

/*
int main(int argc, char* argv[])
{

	IStream*    pstm = NULL ;
	//pstm = CreateMemoryStream() ;
	//_com_ptr_t obj;

	OleInitialize( 0 );

	CLSID clsid;
	_bstr_t progID( "OWC.Pivottable.9" );//"DHTMLEdit.DHTMLEdit" );

	HRESULT hr = CLSIDFromProgID( (LPOLESTR)progID, &clsid );
	
	if ( SUCCEEDED(hr) ) {
		_bstr_t classBody = GenerateClassHeaderFromCOMCLSID( clsid );	
		
		
		printf( "%s", (char*)classBody );
	}

	OleUninitialize();
	
	return 0;
}
*/

CoClassHolder::~CoClassHolder()
{	
	m_implementedInterfaces.clear();
}

InterfaceHolder::~InterfaceHolder()
{
	std::vector<MethodHolder*>::iterator it = m_methods.begin();
	while ( it != m_methods.end() ) 	{
		MethodHolder* mh = *it;
		delete mh;
		mh = NULL;
		it ++;
	}
	m_methods.clear();
}

TypeLibHolder::~TypeLibHolder()
{
	std::vector<CoClassHolder*>::iterator it = m_coClasses.begin();
	while ( it != m_coClasses.end() ) 	{
		CoClassHolder* ch = *it;
		delete ch;
		ch = NULL;
		it ++;
	}
	m_coClasses.clear();

	std::map<_bstr_t,InterfaceHolder*>::iterator it2 = m_interfaces.begin();
	while ( it2 != m_interfaces.end() ) 	{
		InterfaceHolder* ih = it2->second;
		delete ih;
		ih = NULL;
		it2 ++;
	}
	m_interfaces.clear();
}

HRESULT GenerateTypeLibHolder( ITypeLib* pTypeLib, TypeLibHolder& typeLibHolder )
{
	HRESULT hr = E_FAIL;

	typeLibHolder.m_typeDefs = GenerateClassTypeDefs( pTypeLib, 1 );
	BSTR            bstrName = NULL ;
	BSTR            bstrDoc = NULL ;
	BSTR            bstrHelp = NULL ;
	DWORD           dwHelpID ;

	hr = pTypeLib->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp ) ;
	
	typeLibHolder.m_typeLibName = bstrName;

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

	_bstr_t indentStr = "";
	int indent = 0;
	for ( int i=0;i<indent;i++){
		indentStr += "\t";
	}
	int tic = pTypeLib->GetTypeInfoCount();
	for (int ti=0;ti<tic;ti++) {
		ITypeInfo* pTypeInfo = NULL;
		hr = pTypeLib->GetTypeInfo( ti, &pTypeInfo );
		if ( SUCCEEDED(hr) ) {
			TYPEATTR*   pTypeAttr = NULL ;
			hr = pTypeInfo->GetTypeAttr( &pTypeAttr);
			
			switch ( pTypeAttr->typekind ) {
				case TKIND_COCLASS: {								
					hr = pTypeInfo->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp );
					_bstr_t coClassName = bstrName;
					SysFreeString(bstrName) ;
					SysFreeString( bstrDoc ) ;
					SysFreeString( bstrHelp ) ;

					OLECHAR guidStr[256];
					StringFromGUID2( pTypeAttr->guid, guidStr, 256 );

					CoClassHolder* newCoClass = new CoClassHolder();
					newCoClass->m_className = coClassName;
					newCoClass->m_classID = guidStr;
					for (UINT n = 0 ; n < pTypeAttr->cImplTypes ; n++)	{
						ITypeInfo*      ptiImpl = NULL ;
						int impltype = 0;
						TYPEATTR*       pattrImpl = NULL ;
						HREFTYPE href = NULL ;
						hr = pTypeInfo->GetImplTypeFlags( n, &impltype );
						hr = pTypeInfo->GetRefTypeOfImplType(n, &href);
						hr = pTypeInfo->GetRefTypeInfo( href, &ptiImpl );
						hr = ptiImpl->GetTypeAttr( &pattrImpl);
						hr = ptiImpl->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp );
						switch ( pattrImpl->typekind ) {
							case TKIND_INTERFACE: case TKIND_DISPATCH: {
								_bstr_t tmp = bstrName;

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

								std::map<_bstr_t,InterfaceHolder*>::iterator found = 
									typeLibHolder.m_interfaces.find( tmp );
								InterfaceHolder* newInterface = NULL;
								if ( found != typeLibHolder.m_interfaces.end() ) {
									newInterface = found->second;

									typeLibHolder.m_interfaces[tmp] = newInterface;
								}
								else {
									newInterface = new InterfaceHolder();
					
									GenerateInterface( ptiImpl, pattrImpl, newInterface );
								}
								
								newCoClass->m_implementedInterfaces.push_back( newInterface );								
							}
							break;
						}
					}
					typeLibHolder.m_coClasses.push_back( newCoClass );
				}
				break;

				case TKIND_INTERFACE: case TKIND_DISPATCH: {					
					InterfaceHolder* newInterface = new InterfaceHolder();
					
					hr = GenerateInterface( pTypeInfo, pTypeAttr, newInterface );
					_bstr_t tmp = newInterface->m_interfaceName;
					typeLibHolder.m_interfaces[tmp] = newInterface;
				}
				break;
			}
		}
	}
	return hr;
}

HRESULT GenerateMethod( ITypeInfo* pMethodTypeInfo, long methodID, MethodHolder* pMethod )
{
	HRESULT hr = E_FAIL;

	_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 ;

	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 );	
	
	pMethod->m_returnType = TYPEDESCtoString( pMethodTypeInfo, &pfuncdesc->elemdescFunc.tdesc );
		
	if (pfuncdesc->invkind & INVOKE_PROPERTYGET) {
		cNames --;
		pMethod->m_isPropertyGetter = true;
	}
	else if ((pfuncdesc->invkind & INVOKE_PROPERTYPUT) || (pfuncdesc->invkind & INVOKE_PROPERTYPUTREF)) {		
		pMethod->m_isPropertySetter = true;
	}
	pMethod->m_methodName = rgbstrNames[0];
	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 += ", ";
					}

					MethodArgumentHolder methodArg( type, paramName );
					pMethod->m_arguments.push_back( methodArg );
				}
			}
		}
	}
	method += " )";
	pMethod->m_declaration = method;
	TCHAR methIDStr[256];
	memset( methIDStr, 0, 256 );
	sprintf( methIDStr, "%d", pfuncdesc->memid );
	pMethod->m_methodID = methIDStr;

	for (ui = 0 ; ui < MAX_NAMES ; ui++) {
		if (rgbstrNames[ui]) {
			SysFreeString(rgbstrNames[ui]) ;
		}
	}

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

	pMethodTypeInfo->ReleaseFuncDesc( pfuncdesc ) ;		

	return hr;
}

HRESULT GenerateInterface( ITypeInfo* pTypeInfo, TYPEATTR* pTypeAttr, InterfaceHolder* pInterface )
{
	HRESULT hr = E_FAIL;
	BSTR            bstrName = NULL ;
	BSTR            bstrDoc = NULL ;
	BSTR            bstrHelp = NULL ;
	DWORD           dwHelpID ;
	
	hr = pTypeInfo->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp );
	_bstr_t interfaceName = bstrName;
	OLECHAR guidStr[256];
	StringFromGUID2( pTypeAttr->guid, guidStr, 256 );
	
	SysFreeString(bstrName) ;
	SysFreeString( bstrDoc ) ;
	SysFreeString( bstrHelp ) ;

	pInterface->m_interfaceID = guidStr;
	pInterface->m_interfaceName = interfaceName;
	if ( pTypeAttr->typekind == TKIND_INTERFACE ) {
		pInterface->m_superInterfaceName = "IUnknown";
	}
	else if ( pTypeAttr->typekind == TKIND_DISPATCH ) {
		pInterface->m_superInterfaceName = "IDispatch";
	}
	for (UINT i = 0 ; i < pTypeAttr->cFuncs ; i++)	{						
		MethodHolder* methodHolder = new MethodHolder();
		
		hr = GenerateMethod( pTypeInfo, i, methodHolder );		
		CString tmp = (TCHAR*)methodHolder->m_declaration;
		//ignore IUnknown and IDispatch methods
		int pos = tmp.Find( "AddRef(" );
		int pos1 = tmp.Find( "Release(" );
		int pos2 = tmp.Find( "QueryInterface(" );
		int pos3 = tmp.Find( "GetTypeInfoCount(" );
		int pos4 = tmp.Find( "GetTypeInfo(" );
		int pos5 = tmp.Find( "GetIDsOfNames(" );
		int pos6 = tmp.Find( "Invoke(" );		
		bool addMethod = ((pos<0) && (pos1<0) && (pos2<0) && (pos3<0) && (pos4<0) && (pos5<0) && (pos6<0));

		if ( (true == addMethod) && (SUCCEEDED(hr)) ) {
			pInterface->m_methods.push_back( methodHolder );
		}
		else {
			delete methodHolder;
		}
	}
	return hr;
}