开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
TLBODL.CPP
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：52k
源码类别：

Windows编程

开发平台：

Visual C++

TLBODL.CPP：源码内容
  1. // tlbodl.cpp : implementation file
  2. //
  4. // This is a part of the Microsoft Foundation Classes C++ library.
  5. // Copyright (C) 1992-1998 Microsoft Corporation
  6. // All rights reserved.
  7. //
  8. // This source code is only intended as a supplement to the
  9. // Microsoft Foundation Classes Reference and related
  10. // electronic documentation provided with the library.
  11. // See these sources for detailed information regarding the
  12. // Microsoft Foundation Classes product.
  14. #include "stdafx.h"
  15. #include "iviewers.h"
  16. #include "iview.h"
  17. #include "util.h"
  18. #include "iviewers.h"
  19. #include "iviewer.h"
  20. #include "typelib.h"
  21. #include "tree.h"
  22. #include "tlbodl.h"
  24. #ifdef _DEBUG
  25. #undef THIS_FILE
  26. static char BASED_CODE THIS_FILE[] = __FILE__;
  27. #endif
  29. #define MAX_NAMES   64     // max parameters to a function
  31. IStream* CreateMemoryStream();
  32. int StringFromGUID2T(REFGUID rguid, LPTSTR lpszGUID, int cbMax);
  34. // if defined, when typedefs are written out a tag is created
  35. // by concatinating "tag" with the typedef name.
  36. #define _WRITE_TAG 1
  38. /////////////////////////////////////////////////////////////////////////////
  39. // CTypeLibODLView
  41. IMPLEMENT_DYNCREATE(CTypeLibODLView, CEditView)
  43. CTypeLibODLView::CTypeLibODLView()
  44. {
  45. }
  47. CTypeLibODLView::~CTypeLibODLView()
  48. {
  49. }
  52. BEGIN_MESSAGE_MAP(CTypeLibODLView, CEditView)
  53. //{{AFX_MSG_MAP(CTypeLibODLView)
  54. ON_WM_DESTROY()
  55. //}}AFX_MSG_MAP
  56. END_MESSAGE_MAP()
  59. /////////////////////////////////////////////////////////////////////////////
  60. // CTypeLibODLView drawing
  62. void CTypeLibODLView::OnDraw(CDC* pDC)
  63. {
  64. }
  66. /////////////////////////////////////////////////////////////////////////////
  67. // CTypeLibODLView diagnostics
  69. #ifdef _DEBUG
  70. void CTypeLibODLView::AssertValid() const
  71. {
  72. CEditView::AssertValid();
  73. }
  75. void CTypeLibODLView::Dump(CDumpContext& dc) const
  76. {
  77. CEditView::Dump(dc);
  78. }
  79. #endif //_DEBUG
  81. /////////////////////////////////////////////////////////////////////////////
  82. // CTypeLibODLView message handlers
  84. BOOL CTypeLibODLView::PreCreateWindow(CREATESTRUCT& cs)
  85. {
  86. cs.style |= ES_READONLY | ES_MULTILINE | WS_VSCROLL | WS_HSCROLL ;
  88. return CEditView::PreCreateWindow(cs);
  89. }
  91. void CTypeLibODLView::OnInitialUpdate()
  92. {
  93. m_Font.CreateFont( -11, 0, 0, 0, 0, 0,
  94. 0, 0, ANSI_CHARSET, 0, 0, 0,
  95. FIXED_PITCH | FF_DONTCARE, _T("Courier New") ) ;
  97. SetFont( &m_Font );
  98. CEditView::OnInitialUpdate();
  99. }
  101. void CTypeLibODLView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint)
  102. {
  103. CTypeLibWnd* pFrame = (CTypeLibWnd*)GetParent()->GetParent() ;
  104. ASSERT(pFrame->IsKindOf(RUNTIME_CLASS(CTypeLibWnd)));
  106. if (pFrame->m_pSelectedItem == NULL)
  107. {
  108. SetWindowText(_T("")) ;
  109. return ;
  110. }
  112. SetRedraw( FALSE ) ;
  113. BeginWaitCursor() ;
  115. CString     sText;
  116. HRESULT     hr = S_OK ;
  117. IStream*    pstm = NULL ;
  119. TRY
  120. {
  121. pstm = CreateMemoryStream() ;
  123. switch(pFrame->m_pSelectedItem->m_Type)
  124. {
  125. case CTreeItem::typeTypeLib:
  126. case CTreeItem::typeTypeLib2:
  127.  hr = DeCompileTypeLib( pstm, pFrame->m_pSelectedItem->GetTypeLib() ) ;
  128. break ;
  130. case CTreeItem::typeEnum:
  131. case CTreeItem::typeRecord:
  132. case CTreeItem::typeModule:
  133. case CTreeItem::typeInterface:
  134. case CTreeItem::typeDispinterface:
  135. case CTreeItem::typeCoClass:
  136. case CTreeItem::typeAlias:
  137. case CTreeItem::typeUnion:
  138. case CTreeItem::typeTypeInfo:
  139. case CTreeItem::typeTypeInfo2:
  140. switch(pFrame->m_pSelectedItem->GetTypeKind())
  141. {
  142. case TKIND_ENUM:
  143. case TKIND_RECORD:
  144. case TKIND_UNION:
  145. case TKIND_ALIAS:
  146.  hr = DeCompileTypedef( pstm, pFrame->m_pSelectedItem->GetTypeInfo() ) ;
  147. break ;
  149. case TKIND_MODULE:
  150.  hr = DeCompileModule( pstm, pFrame->m_pSelectedItem->GetTypeInfo() ) ;
  151. break ;
  153. case TKIND_INTERFACE:
  154.  hr = DeCompileInterface( pstm, pFrame->m_pSelectedItem->GetTypeInfo() ) ;
  155. break ;
  157. case TKIND_DISPATCH:
  158.  hr = DeCompileDispinterface( pstm, pFrame->m_pSelectedItem->GetTypeInfo() ) ;
  159. break ;
  161. case TKIND_COCLASS:
  162.  hr = DeCompileCoClass( pstm, pFrame->m_pSelectedItem->GetTypeInfo() ) ;
  163. break ;
  165. default:
  166. sText = _T("<<unclassified typeinfo>>");
  167. break ;
  168. }
  169. break ;
  171. case CTreeItem::typeMethod:
  172.  hr = DeCompileFunc( pstm, pFrame->m_pSelectedItem->GetTypeInfo(), pFrame->m_pSelectedItem->m_uiMemid ) ;
  173. break ;
  175. case CTreeItem::typeProperty:
  176.  hr = DeCompileVar( pstm, pFrame->m_pSelectedItem->GetTypeInfo(), pFrame->m_pSelectedItem->m_uiMemid ) ;
  177. break ;
  179. case CTreeItem::typeConstant:
  180.  hr = DeCompileConst( pstm, pFrame->m_pSelectedItem->GetTypeInfo(), pFrame->m_pSelectedItem->m_uiMemid ) ;
  181. break ;
  183. case CTreeItem::typeUnknown:
  184. case CTreeItem::typeUnknown2:
  185. case CTreeItem::typeEnums:
  186. case CTreeItem::typeRecords:
  187. case CTreeItem::typeModules:
  188. case CTreeItem::typeInterfaces:
  189. case CTreeItem::typeDispinterfaces:
  190. case CTreeItem::typeCoClasses:
  191. case CTreeItem::typeAliases:
  192. case CTreeItem::typeUnions:
  193. case CTreeItem::typeMethods:
  194. case CTreeItem::typeMethods2:
  195. case CTreeItem::typeProperties:
  196. case CTreeItem::typeProperties2:
  197. case CTreeItem::typeConstants:
  198. case CTreeItem::typeConstants2:
  199. case CTreeItem::typeImplTypes:
  200. case CTreeItem::typeImplTypes2:
  201. default:
  202. //bstr = ::SysAllocString(OLESTR(""));
  203. break ;
  204. }
  206. if (hr != S_OK)
  207. AfxThrowOleException( hr ) ;
  209. if (pstm)
  210. {
  211. STATSTG statstg ;
  212. if (FAILED(hr = pstm->Stat( &statstg,STATFLAG_NONAME )))
  213. AfxThrowOleException( hr ) ;
  215. // Seek to beginning
  216. LARGE_INTEGER li ;
  217. LISet32( li, 0 ) ;
  218. if (FAILED(hr = pstm->Seek( li, STREAM_SEEK_SET, NULL )))
  219. AfxThrowOleException( hr ) ;
  221. // Read into string
  222. LPSTR lpszBuf = sText.GetBuffer(statstg.cbSize.LowPart+1);
  223. if (FAILED(hr = pstm->Read( lpszBuf, statstg.cbSize.LowPart, NULL )))
  224. AfxThrowOleException( hr ) ;
  225. lpszBuf[statstg.cbSize.LowPart] = '';
  226. sText.ReleaseBuffer();
  227. }
  228. SetWindowText(sText);
  229. pstm->Release() ;
  230. }
  231. CATCH(CException, pException)
  232. {
  233. SetWindowText( _T("// Could not decompile selected item") ) ;
  234. if (pstm)
  235. pstm->Release() ;
  237. if (pException->IsKindOf(RUNTIME_CLASS(COleException)))
  238. hr = ((COleException*)pException)->m_sc ;
  239. else if (pException->IsKindOf(RUNTIME_CLASS(COleException)))
  240. hr = E_OUTOFMEMORY ;
  242. if (hr == S_OK)
  243. hr = GetLastError() ;
  245. ErrorMessage( "Could not decompile selected item", hr ) ;
  246. }
  247. END_CATCH
  249. SetRedraw( TRUE ) ;
  250. EndWaitCursor() ;
  251. SendMessage(EM_SETSEL, 0, 0)  ;
  252. }
  254. void CTypeLibODLView::OnDestroy()
  255. {
  256. CEditView::OnDestroy();
  258. m_Font.DeleteObject() ;
  259. }
  261. // Write string s with no indent and no CR
  262. #define WRITE( s )          WriteLine( pstm, s, 0, FALSE )
  264. // Write string s with indent and no CR
  265. #define WRITE1( s )         WriteLine( pstm, s, uiIndent, FALSE )
  266. #define WRITE2( s, ui )     WriteLine( pstm, s, uiIndent+ui, FALSE )
  268. // Write string s with indent and CR
  269. #define WRITELINE( s )      WriteLine( pstm, s, uiIndent, TRUE )
  270. #define WRITELINE2( s, ui ) WriteLine( pstm, s, uiIndent+ui, TRUE )
  271. #define WRITECR( s )        WriteLine( pstm, s, 0, TRUE )
  273. #define WRITERAW( p, len )     WriteRaw( pstm, p, len )
  274. #define WRITEBSTR( p )         WriteBSTR( pstm, p )
  276. inline void WriteRaw( IStream* pstm, const void* pv, UINT cb )
  277. {
  278. HRESULT hr ;
  279. if (FAILED(hr = pstm->Write( pv, cb, NULL )))
  280. AfxThrowOleException( hr ) ;
  281. }
  283. inline void WriteLine( IStream* pstm, const CString &rstr, UINT uiIndent, BOOL fNewLine )
  284. {
  285. while(uiIndent--)
  286. {
  287. WriteRaw( pstm, _T("    "), 4 * sizeof(TCHAR));
  288. }
  290. WriteRaw( pstm, rstr, rstr.GetLength() * sizeof(TCHAR)) ;
  292. if (fNewLine)
  293. WriteRaw(pstm, _T("rn"), 2 * sizeof(TCHAR)) ;
  294. }
  296. inline void WriteBSTR( IStream* pstm, BSTR bstr )
  297. {
  298. UINT len = ::SysStringLen(bstr) ;
  299. if (!len)
  300. return ;
  302. USES_CONVERSION;
  303. LPTSTR lpszSource = OLE2T(bstr);
  304. TCHAR *pstrTemp = new TCHAR[((len + 1) * sizeof(TCHAR)) * 2];
  305. LPTSTR lpD, lpS = lpszSource ;
  307. lpD = pstrTemp;
  308. for (UINT n = 0 ; n < len ; n++)
  309. {
  310. if (!isprint(*lpS) || (*lpS) == '"' || (*lpS) == '\')
  311. {
  312. // "  \ a  b  f  n  r  t  v
  313. *lpD++ = '\' ;
  314. switch(*lpS)
  315. {
  316. case '"':
  317. *lpD++ = '"' ;
  318. break ;
  319. case '\':
  320. *lpD++ = '\' ;
  321. break ;
  322. case 'a':
  323. *lpD++ = 'a' ;
  324. break ;
  325. case 'b':
  326. *lpD++ = 'b' ;
  327. break ;
  328. case 'f':
  329. *lpD++ = 'f' ;
  330. break ;
  331. case 'n':
  332. *lpD++ = 'n' ;
  333. break ;
  334. case 'r':
  335. *lpD++ = 'r' ;
  336. break ;
  337. case 't':
  338. *lpD++ = 't' ;
  339. break ;
  340. case 'v':
  341. *lpD++ = 'v' ;
  342. break ;
  343. case '':
  344. *lpD++ = '0' ;
  345. break ;
  346. default:
  347. lpD += wsprintf( lpD, _T("x%02X"), (UINT)*lpS );
  348. break ;
  349. }
  350. lpS++;
  351. }
  352. else
  353. *lpD++ = *lpS++;
  354. }
  355. *lpD = '';
  357. WriteRaw( pstm, pstrTemp, lstrlen(pstrTemp)*sizeof(TCHAR) ) ;
  358. delete []pstrTemp ;
  359. }
  361. //  // typelib.tlb
  362. //  [
  363. //    uuid(<00026b00-0000-0000-C000-000000000046>),
  364. //    version (<major>.<minor>),
  365. //    helpfile ("<helpfile.hlp>"),
  366. //    helpstring("<helpstring>"),
  367. //    helpcontext(<helpcontext>)
  368. //  ]
  369. //  library <libname>
  370. //  {
  371. //      importlib("<import.tlb>");
  372. //
  373. //  };
  374. HRESULT CTypeLibODLView::DeCompileTypeLib( IStream* pstm, ITypeLib* ptlb, UINT uiIndent /* = 0 */ )
  375. {
  376. USES_CONVERSION;
  377. HRESULT         hr = S_OK ;
  378. BSTR            bstrName = NULL ;
  379. BSTR            bstrDoc = NULL ;
  380. BSTR            bstrHelp = NULL ;
  381. DWORD           dwHelpID ;
  382. TLIBATTR*       plibattr = NULL ;
  383. ITypeInfo*      pti = NULL ;
  384. TYPEATTR*       pattr = NULL ;
  386. ASSERT(ptlb) ;
  388. TRY
  389. {
  390. TCHAR szGUID[64] ;
  391. CString str;
  392. hr = ptlb->GetLibAttr(&plibattr);
  393. if (FAILED(hr))
  394. AfxThrowOleException( hr ) ;
  396. // write header with library filename
  397. WRITELINE(_T("// Generated .ODL file (by Ole2View)"));
  398. WRITELINE(_T("// "));
  399. WRITE1(_T("// typelib filename: "));
  400. hr = ::QueryPathOfRegTypeLib(plibattr->guid, plibattr->wMajorVerNum, plibattr->wMinorVerNum, plibattr->lcid, &bstrName);
  401. if (SUCCEEDED(hr))
  402. {
  403. LPCTSTR lpszName = OLE2CT(bstrName);
  404. ::SysFreeString(bstrName);
  405. bstrName = NULL;
  407. LPTSTR p = _tcsrchr(lpszName, '\');
  408. if (p != NULL && *p && *(p+1))
  409. WRITECR( p+1 ) ;
  410. else
  411. WRITECR( lpszName ) ;
  412. }
  413. else
  414. {
  415. // It's possible we're viewing a type lib that was never registered
  416. WRITECR( _T("<could not determine filename>") ) ;
  417. }
  419. WRITELINE( _T("[") ) ;
  421. StringFromGUID2T( plibattr->guid, szGUID, sizeof(szGUID) );
  422. WRITE1(_T("  uuid(")) ; WRITE(szGUID); WRITECR(_T("),"))  ;
  424. str.Format( _T("  version(%d.%d)"), plibattr->wMajorVerNum, plibattr->wMinorVerNum ) ;
  425. WRITE1(str) ;
  427. hr = ptlb->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp );
  428. if (FAILED(hr))
  429. AfxThrowOleException( hr ) ;
  431. if (bstrDoc && *bstrDoc)
  432. {
  433. WRITECR(_T(",")) ;
  434. WRITE1(_T("  helpstring("")) ;
  435. WRITEBSTR( bstrDoc ) ;
  436. WRITE(_T("")")) ;
  437. }
  439. if (bstrHelp && *bstrHelp)
  440. {
  441. WRITECR(",") ;
  442. LPCTSTR lpszHelp = OLE2CT(bstrHelp);
  443. ::SysFreeString(bstrHelp);
  444. bstrHelp = NULL;
  446. LPTSTR p = _tcsrchr(lpszHelp, '\');
  447. if (p != NULL && *p && *(p+1))
  448. str.Format( _T("  helpfile("%s"),"), p+1 ) ;
  449. else
  450. str.Format( _T("  helpfile("%s"),"), lpszHelp ) ;
  451. WRITELINE( str ) ;
  452. str.Format( _T("  helpcontext(%#08.8x)"), dwHelpID ) ;
  453. WRITE1( str ) ;
  454. }
  456. WRITECR(_T("")) ;
  457. WRITELINE(_T("]") ) ;
  459. WRITE1( _T("library ") ) ;
  460. WRITEBSTR(bstrName) ;
  461. WRITECR(_T("")) ;
  463. WRITELINE( _T("(") ) ;
  465. // TODO:  Grovel through all typeinfos for any referenced types
  466. // that are defined in imported libs
  467. //uiInfos = ptlb->GetTypeInfoCount() ;
  468. //for (UINT n = 0 ; n < uiInfos ; n++)
  469. //{
  470. //}
  471. WRITELINE(_T("// BUGBUG:  There most likely were "importlib()" statements in"));
  472. WRITELINE(_T("//          in the source.  While it appears possible to be able"));
  473. WRITELINE(_T("//          to identify them, it is non-trivial and is currently"));
  474. WRITELINE(_T("//          not supported."));
  475. WRITELINE(_T("// "));
  477. UINT uiInfos = ptlb->GetTypeInfoCount() ;
  478. for (UINT n = 0 ; n < uiInfos ; n++)
  479. {
  480. if (FAILED(hr = ptlb->GetTypeInfo( n, &pti )))
  481. AfxThrowOleException(hr) ;
  483. if (FAILED(hr = pti->GetTypeAttr( &pattr )))
  484. AfxThrowOleException(hr) ;
  486. switch(pattr->typekind)
  487. {
  488. case TKIND_ENUM:
  489. case TKIND_RECORD:
  490. case TKIND_UNION:
  491. case TKIND_ALIAS:
  492.  hr = DeCompileTypedef( pstm, pti, uiIndent + 1 ) ;
  493. break ;
  495. case TKIND_MODULE:
  496.  hr = DeCompileModule( pstm, pti, uiIndent + 1 ) ;
  497. break ;
  499. case TKIND_INTERFACE:
  500.  hr = DeCompileInterface( pstm, pti, uiIndent + 1 ) ;
  501. break ;
  503. case TKIND_DISPATCH:
  504.  hr = DeCompileDispinterface( pstm, pti, uiIndent + 1 ) ;
  505. break ;
  507. case TKIND_COCLASS:
  508.  hr = DeCompileCoClass( pstm, pti, uiIndent + 1 ) ;
  509. break ;
  510. }
  512. if (n != uiInfos - 1)
  513. WRITECR(_T("")) ;
  515. pti->ReleaseTypeAttr( pattr ) ;
  516. pti->Release() ;
  517. pti = NULL ;
  518. pattr = NULL ;
  519. }
  520. // Last line of the .ODL file
  521. WRITELINE( ");" ) ;
  523. SysFreeString( bstrName ) ;
  524. bstrName = NULL ;
  525. SysFreeString( bstrDoc ) ;
  526. bstrDoc = NULL ;
  527. SysFreeString( bstrHelp ) ;
  528. bstrHelp = NULL ;
  530. if (plibattr)
  531. ptlb->ReleaseTLibAttr( plibattr ) ;
  532. }
  533. CATCH(CException, pException)
  534. {
  535. if (pti)
  536. {
  537. if (pattr)
  538. pti->ReleaseTypeAttr( pattr ) ;
  539. pti->Release() ;
  540. }
  541. if (plibattr)
  542. ptlb->ReleaseTLibAttr( plibattr ) ;
  543. if (bstrName)
  544. SysFreeString( bstrName ) ;
  545. if (bstrDoc)
  546. SysFreeString( bstrDoc ) ;
  547. if (bstrHelp)
  548. SysFreeString( bstrHelp ) ;
  550. THROW_LAST() ;
  551. }
  552. END_CATCH
  554. return hr ;
  555. }
  557. // if typekind == TKIND_ALIAS
  558. //      typedef [attributes] basetype aliasname;
  559. //
  560. // if typekind == TKIND_ENUM
  561. //  typedef [attributes] enum [tag] {
  562. //      enumlist
  563. //  } enumname;
  564. // enumlist is made up of members of the form
  565. //      name = value,
  566. // or "= value" can be ommitted
  567. //
  568. // if typekind == TKIND_UNION or TKIND_RECORD
  569. // typedef [attributes] union/struct [tag] {
  570. //      memberlist
  571. // } union/structname;
  572. //
  573. // attributes can be
  574. //      [uuid(<00026b00-0000-0000-C000-000000000046>), version (<major>.<minor>),
  575. //       helpstring("<helpstring>"), helpcontext(<id), hidden, restricted,
  576. //       public]
  577. //
  578. // memberlist is made up of members of the form
  579. //      type name[bounds];
  580. //
  581. HRESULT CTypeLibODLView::DeCompileTypedef( IStream* pstm, ITypeInfo* pti, UINT uiIndent /* = 0 */ )
  582. {
  583. USES_CONVERSION;
  584. HRESULT     hr = S_OK ;
  585. TYPEATTR*   pattr = NULL ;
  586. BSTR            bstrName = NULL ;
  587. BSTR            bstrDoc = NULL ;
  588. BSTR            bstrHelp = NULL ;
  589. DWORD           dwHelpID ;
  591. WRITE1("typedef ") ;
  593. TRY
  594. {
  595. if (FAILED(hr = pti->GetTypeAttr( &pattr)))
  596. AfxThrowOleException( hr ) ;
  598. BOOL    fAttributes = FALSE ;      // any attributes?
  599. BOOL    fAttribute = FALSE ;       // at least one (insert ",")
  601. // Was 'uuid' specified?
  602. if (!IsEqualGUID( pattr->guid, GUID_NULL ))
  603. {
  604. TCHAR szGUID[64] ;
  605. StringFromGUID2T( pattr->guid, szGUID, sizeof(szGUID) ) ;
  606. fAttributes = TRUE ;
  607. WRITE("[uuid(") ;
  608. WRITE(szGUID) ;
  609. WRITE(")") ;
  610. fAttribute = TRUE ;
  611. }
  613. // was version specified
  614. if (pattr->wMajorVerNum || pattr->wMinorVerNum)
  615. {
  616. if (fAttributes == FALSE)
  617. WRITE("[") ;
  618. fAttributes = TRUE ;
  619. if (fAttribute)
  620. WRITE(", ") ;
  622. CString str ;
  623. str.Format(_T("version(%d.%d)"), pattr->wMajorVerNum, pattr->wMinorVerNum) ;
  624. WRITE(str) ;
  625. fAttribute = TRUE ;
  626. }
  628. if (SUCCEEDED(pti->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp )))
  629. {
  630. CString str ;
  631. if (bstrDoc && *bstrDoc)
  632. {
  633. if (fAttributes == FALSE) WRITE("[") ;
  634. fAttributes = TRUE ;
  635. if (fAttribute)
  636. WRITE(", ") ;
  637. LPCTSTR lpszDoc = OLE2CT(bstrDoc);
  638. ::SysFreeString(bstrDoc);
  639. bstrDoc = NULL;
  641. str.Format( _T("helpstring("%s")"), lpszDoc );
  642. WRITE( str ) ;
  643. if (dwHelpID > 0)
  644. {
  645. str.Format( _T(", helpcontext(%#08.8x)"), dwHelpID ) ;
  646. WRITE( str ) ;
  647. }
  648. }
  649. else if (dwHelpID > 0)
  650. {
  651. if (fAttributes == FALSE) WRITE("[") ;
  652. fAttributes = TRUE ;
  653. if (fAttribute)
  654. WRITE(", ") ;
  655. str.Format( _T("helpcontext(%#08.8x)"), dwHelpID ) ;
  656. WRITE( str ) ;
  657. fAttribute = TRUE ;
  658. }
  659. }
  661. if (pattr->typekind == TKIND_ALIAS)
  662. {
  663. if (fAttributes == FALSE) WRITE("[") ;
  664. fAttributes = TRUE ;
  665. if (fAttribute)
  666. WRITE(", ") ;
  667. WRITE("public") ;       // if it's in the tlb it had public
  668. }
  670. if (fAttributes)
  671. WRITE("] ") ;
  673. switch(pattr->typekind)
  674. {
  675. case TKIND_RECORD:
  676. #ifdef _WRITE_TAG
  677. WRITE("struct tag") ;
  678. WRITEBSTR(bstrName) ;
  679. #else
  680. WRITE("struct ") ;
  681. #endif
  682. WRITECR(" {" );
  683. break ;
  685. case TKIND_UNION:
  686. #ifdef _WRITE_TAG
  687. WRITE("union tag") ;
  688. WRITEBSTR(bstrName) ;
  689. #else
  690. WRITE("union ") ;
  691. #endif
  692. WRITECR(" {" );
  693. break ;
  695. case TKIND_ALIAS:  //typedef
  696. // write base type
  697. WRITE(TYPEDESCtoString( pti, &pattr->tdescAlias )) ;
  698. WRITE(" ") ;
  700. // write aliasname
  701. break ;
  703. case TKIND_ENUM:
  704. WRITECR("enum {" );
  705. break ;
  707. default:
  708. ASSERT(0) ;
  709. break ;
  710. }
  712. if (pattr->typekind == TKIND_RECORD || pattr->typekind == TKIND_UNION)
  713. {
  714. for (UINT n = 0 ; n < pattr->cVars ; n++)
  715. DumpVar( pstm, pti, pattr, n, uiIndent + 1 ) ;
  716. WRITE1("} ");
  717. }
  719. if (pattr->typekind == TKIND_ENUM)
  720. {
  721. for (int n = 0 ; n < pattr->cVars ; n++)
  722. {
  723. DumpConst( pstm, pti, pattr, n, uiIndent + 1, FALSE ) ;
  724. if (n < pattr->cVars-1)
  725. WRITECR(",") ;
  726. else
  727. WRITECR("") ;
  728. }
  729. WRITE1("} ");
  730. }
  732. WRITEBSTR(bstrName) ;
  733. WRITECR(";") ;
  736. if (bstrName)
  737. SysFreeString( bstrName ) ;
  738. if (bstrDoc)
  739. SysFreeString( bstrDoc ) ;
  740. if (bstrHelp)
  741. SysFreeString( bstrHelp ) ;
  743. pti->ReleaseTypeAttr( pattr ) ;
  744. }
  745. CATCH(CException, pException)
  746. {
  747. if (bstrName)
  748. SysFreeString( bstrName ) ;
  749. if (bstrDoc)
  750. SysFreeString( bstrDoc ) ;
  751. if (bstrHelp)
  752. SysFreeString( bstrHelp ) ;
  753. if (pattr)
  754. pti->ReleaseTypeAttr( pattr ) ;
  756. THROW_LAST();
  757. }
  758. END_CATCH
  759. return hr ;
  760. }
  762. //  [
  763. //    attributes
  764. //  ]
  765. //  module modulename {
  766. //      elementlist
  767. //  };
  768. //  attributes are
  769. //      uuid, version, helpstring, helpcontext, dllname
  770. //      The dllname attribute is required.
  771. //
  772. //  [attributes] returntype [calling convention] funcname(params);
  773. //  [attributes] const constname = constval;
  774. //
  775. HRESULT CTypeLibODLView::DeCompileModule( IStream* pstm, ITypeInfo* pti, UINT uiIndent /* = 0 */ )
  776. {
  777. HRESULT     hr = S_OK ;
  778. TYPEATTR*   pattr = NULL ;
  779. BSTR            bstrName = NULL ;
  780. BSTR            bstrDoc = NULL ;
  781. BSTR            bstrHelp = NULL ;
  782. DWORD           dwHelpID ;
  784. TRY
  785. {
  786. if (FAILED(hr = pti->GetTypeAttr( &pattr)))
  787. AfxThrowOleException( hr ) ;
  789. WRITELINE(_T("// BUGBUG:   There appears to be no way to retrieve the dllname of"));
  790. WRITELINE(_T("//           a module via ITypeInfo in a reliable way. "));
  791. WRITELINE(_T("//           ITypeInfo::GetDllEntry offers a possibility, but it will"));
  792. WRITELINE(_T("//           only work if the module has entries in it."));
  793. WRITELINE(_T("// "));
  795. WRITELINE(_T("[")) ;
  796. WRITE1( _T("  dllname(")) ;
  798. /*
  799. if (FAILED(hr = pti->GetDllEntry(MEMBERID_NIL, INVOKE_FUNC, &bstrName, NULL, NULL)))
  800. AfxThrowOleException( hr ) ;
  802. WRITEBSTR(bstrName) ;
  803. SysFreeString(bstrName) ;
  804. bstrName = NULL ;
  805. */
  807. WRITE(_T(")")) ;
  809. // Was 'uuid' specified?
  810. if (!IsEqualGUID( pattr->guid, GUID_NULL ))
  811. {
  812. TCHAR szGUID[64] ;
  813. StringFromGUID2T( pattr->guid, szGUID, sizeof(szGUID) ) ;
  814. WRITECR(",") ;
  815. WRITE1("  uuid(") ;
  816. WRITE(szGUID) ;
  817. WRITE(")") ;
  818. }
  820. // was version specified
  821. if (pattr->wMajorVerNum || pattr->wMinorVerNum)
  822. {
  823. WRITECR(",") ;
  824. CString str ;
  825. str.Format(_T("  version(%d.%d)"), pattr->wMajorVerNum, pattr->wMinorVerNum) ;
  826. WRITE1(str) ;
  827. }
  829. if (SUCCEEDED(pti->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp )))
  830. {
  831. CString str ;
  832. if (bstrDoc && *bstrDoc)
  833. {
  834. WRITECR(",") ;
  835. USES_CONVERSION;
  836. LPCTSTR lpszDoc = OLE2CT(bstrDoc);
  837. ::SysFreeString(bstrDoc);
  838. bstrDoc = NULL;
  839. str.Format( _T("  helpstring("%s")"), lpszDoc ) ;
  840. WRITE1( str ) ;
  841. if (dwHelpID > 0)
  842. {
  843. WRITECR(",") ;
  844. str.Format( _T("  helpcontext(%#08.8x)"), dwHelpID ) ;
  845. WRITE1( str ) ;
  846. }
  847. }
  848. else if (dwHelpID > 0)
  849. {
  850. WRITECR(",") ;
  851. str.Format( _T("  helpcontext(%#08.8x)"), dwHelpID ) ;
  852. WRITE1( str ) ;
  853. }
  854. }
  856. WRITECR("") ;
  857. WRITELINE(_T("]")) ;
  858. WRITE1(_T("module ")) ;
  859. WRITEBSTR( bstrName ) ;
  860. WRITECR( _T(" {")) ;
  862. for (int n = 0 ; n < pattr->cFuncs ; n++)
  863. DumpFunc( pstm, pti, pattr, n, uiIndent + 1 ) ;
  865. for (n = 0 ; n < pattr->cVars ; n++)
  866. DumpConst( pstm, pti, pattr, n, uiIndent + 1, TRUE ) ;
  868. WRITELINE("};") ;
  871. if (bstrName)
  872. SysFreeString( bstrName ) ;
  873. if (bstrDoc)
  874. SysFreeString( bstrDoc ) ;
  875. if (bstrHelp)
  876. SysFreeString( bstrHelp ) ;
  878. pti->ReleaseTypeAttr( pattr ) ;
  879. }
  880. CATCH(CException, pException)
  881. {
  882. if (bstrName)
  883. SysFreeString( bstrName ) ;
  884. if (bstrDoc)
  885. SysFreeString( bstrDoc ) ;
  886. if (bstrHelp)
  887. SysFreeString( bstrHelp ) ;
  888. if (pattr)
  889. pti->ReleaseTypeAttr( pattr ) ;
  891. THROW_LAST();
  892. }
  893. END_CATCH
  894. return hr ;
  895. }
  897. //  [
  898. //    attributes
  899. //  ]
  900. //  interface interfacename  [:baseinterface] {
  901. //      functionlist
  902. //  };
  903. //
  904. //  attributes include source, default, and restricted
  905. //
  906. HRESULT CTypeLibODLView::DeCompileInterface( IStream* pstm, ITypeInfo* pti, UINT uiIndent /* = 0 */ )
  907. {
  908. HRESULT     hr = S_OK ;
  909. TYPEATTR*   pattr = NULL ;
  910. BSTR            bstrName = NULL ;
  911. BSTR            bstrDoc = NULL ;
  912. BSTR            bstrHelp = NULL ;
  913. DWORD           dwHelpID ;
  914. ITypeInfo*      ptiImpl = NULL ;
  916. TRY
  917. {
  918. if (FAILED(hr = pti->GetTypeAttr( &pattr)))
  919. AfxThrowOleException( hr ) ;
  921. WRITELINE(_T("[")) ;
  922. WRITE1( _T("  odl")) ;
  924. TCHAR szGUID[64] ;
  925. StringFromGUID2T( pattr->guid, szGUID, sizeof(szGUID) ) ;
  926. WRITECR(",") ;
  927. WRITE1("  uuid(") ;
  928. WRITE(szGUID) ;
  929. WRITE(")") ;
  931. // was version specified
  932. if (pattr->wMajorVerNum || pattr->wMinorVerNum)
  933. {
  934. WRITECR(",") ;
  935. CString str ;
  936. str.Format(_T("  version(%d.%d)"), pattr->wMajorVerNum, pattr->wMinorVerNum) ;
  937. WRITE1(str) ;
  938. }
  940. if (SUCCEEDED(pti->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp )))
  941. {
  942. CString str ;
  943. if (bstrDoc && *bstrDoc)
  944. {
  945. WRITECR(",") ;
  946. USES_CONVERSION;
  947. LPCTSTR lpszDoc = OLE2CT(bstrDoc);
  948. ::SysFreeString(bstrDoc);
  949. bstrDoc = NULL;
  950. str.Format( _T("  helpstring("%s")"), lpszDoc ) ;
  951. WRITE1( str ) ;
  952. if (dwHelpID > 0)
  953. {
  954. WRITECR(",") ;
  955. str.Format( _T("  helpcontext(%#08.8x)"), dwHelpID ) ;
  956. WRITE1( str ) ;
  957. }
  958. }
  959. else if (dwHelpID > 0)
  960. {
  961. WRITECR(",") ;
  962. str.Format( _T("  helpcontext(%#08.8x)"), dwHelpID ) ;
  963. WRITE1( str ) ;
  964. }
  965. }
  967. // source, default, or restricted
  968. if (pattr->wTypeFlags == TYPEFLAG_FHIDDEN)
  969. {
  970. WRITECR(",") ;
  971. WRITE1("  hidden") ;
  972. }
  974. /*
  975. int    implflags = NULL ;
  976. if (FAILED(hr = pti->GetImplTypeFlags(0, &implflags )))
  977. AfxThrowOleException(hr) ;
  979. if (implflags & IMPLTYPEFLAG_FDEFAULT)
  980. {
  981. WRITECR(",") ;
  982. WRITE1("  default") ;
  983. }
  985. if (implflags & IMPLTYPEFLAG_FSOURCE)
  986. {
  987. WRITECR(",") ;
  988. WRITE1("  source") ;
  989. }
  991. if (implflags & IMPLTYPEFLAG_FRESTRICTED)
  992. {
  993. WRITECR(",") ;
  994. WRITE1("  restricted") ;
  995. }
  996.  */
  998. WRITECR("") ;
  999. WRITELINE(_T("]")) ;
  1000. WRITE1(_T("interface ")) ;
  1001. // interface name
  1002. WRITEBSTR( bstrName ) ;
  1004. if (bstrName)
  1005. SysFreeString( bstrName ) ;
  1006. if (bstrDoc)
  1007. SysFreeString( bstrDoc ) ;
  1008. if (bstrHelp)
  1009. SysFreeString( bstrHelp ) ;
  1010. bstrName = bstrDoc = bstrHelp = NULL ;
  1012. // is there a base interface?
  1013. for (UINT n = 0 ; n <  pattr->cImplTypes; n++)
  1014. {
  1015. HREFTYPE href = NULL ;
  1016. if (FAILED(hr = pti->GetRefTypeOfImplType(n, &href)))
  1017. AfxThrowOleException(hr) ;
  1019. if (FAILED(hr = pti->GetRefTypeInfo( href, &ptiImpl )))
  1020. AfxThrowOleException(hr) ;
  1022. if (FAILED(hr = ptiImpl->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp )))
  1023. AfxThrowOleException(hr) ;
  1025. WRITE(_T(" : ")) ;
  1026. WRITEBSTR( bstrName ) ;
  1028. SysFreeString( bstrName ) ;
  1029. bstrName = NULL ;
  1030. SysFreeString( bstrDoc ) ;
  1031. bstrDoc = NULL ;
  1032. SysFreeString( bstrHelp ) ;
  1033. bstrHelp = NULL ;
  1035. ptiImpl->Release() ;
  1036. ptiImpl = NULL ;
  1037. }
  1039. WRITECR(_T(" {")) ;
  1041. for (n = 0 ; n < pattr->cFuncs ; n++)
  1042. DumpFunc( pstm, pti, pattr, n, uiIndent + 1 ) ;
  1044. WRITELINE("};") ;
  1046. if (bstrName)
  1047. SysFreeString( bstrName ) ;
  1048. if (bstrDoc)
  1049. SysFreeString( bstrDoc ) ;
  1050. if (bstrHelp)
  1051. SysFreeString( bstrHelp ) ;
  1053. pti->ReleaseTypeAttr( pattr ) ;
  1054. }
  1055. CATCH(CException, pException)
  1056. {
  1057. if (ptiImpl)
  1058. ptiImpl->Release() ;
  1060. if (bstrName)
  1061. SysFreeString( bstrName ) ;
  1062. if (bstrDoc)
  1063. SysFreeString( bstrDoc ) ;
  1064. if (bstrHelp)
  1065. SysFreeString( bstrHelp ) ;
  1066. if (pattr)
  1067. pti->ReleaseTypeAttr( pattr ) ;
  1069. THROW_LAST();
  1070. }
  1071. END_CATCH
  1072. return hr ;
  1073. }
  1076. //  Syntax 1
  1077. //
  1078. //  [
  1079. //    attributes
  1080. //  ]
  1081. //  dispinterface intfname {
  1082. //      properties:
  1083. //          proplist
  1084. //      methods:
  1085. //          methlist
  1086. //  };
  1087. //
  1088. //  Syntax 2
  1089. //
  1090. //  [
  1091. //    attributes
  1092. //  ]
  1093. //  dispinterface intfname {
  1094. //      interface interfacename
  1095. //  };
  1096. //
  1097. HRESULT CTypeLibODLView::DeCompileDispinterface( IStream* pstm, ITypeInfo* pti, UINT uiIndent /* = 0 */ )
  1098. {
  1099. HRESULT     hr = S_OK ;
  1100. TYPEATTR*   pattr = NULL ;
  1101. BSTR            bstrName = NULL ;
  1102. BSTR            bstrDoc = NULL ;
  1103. BSTR            bstrHelp = NULL ;
  1104. DWORD           dwHelpID ;
  1105. ITypeInfo*      ptiImpl = NULL ;
  1107. TRY
  1108. {
  1109. if (FAILED(hr = pti->GetTypeAttr( &pattr)))
  1110. AfxThrowOleException( hr ) ;
  1112. WRITELINE(_T("[")) ;
  1114. TCHAR szGUID[64] ;
  1115. StringFromGUID2T( pattr->guid, szGUID, sizeof(szGUID) ) ;
  1116. WRITE1("  uuid(") ;
  1117. WRITE(szGUID) ;
  1118. WRITE(")") ;
  1120. // was version specified
  1121. if (pattr->wMajorVerNum || pattr->wMinorVerNum)
  1122. {
  1123. WRITECR(",") ;
  1124. CString str ;
  1125. str.Format(_T("  version(%d.%d)"), pattr->wMajorVerNum, pattr->wMinorVerNum) ;
  1126. WRITE1(str) ;
  1127. }
  1129. if (SUCCEEDED(pti->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp )))
  1130. {
  1131. CString str ;
  1132. if (bstrDoc && *bstrDoc)
  1133. {
  1134. WRITECR(",") ;
  1135. USES_CONVERSION;
  1136. LPCTSTR lpszDoc = OLE2CT(bstrDoc);
  1137. ::SysFreeString(bstrDoc);
  1138. bstrDoc = NULL;
  1139. str.Format( _T("  helpstring("%s")"), lpszDoc ) ;
  1140. WRITE1( str ) ;
  1141. if (dwHelpID > 0)
  1142. {
  1143. WRITECR(",") ;
  1144. str.Format( _T("  helpcontext(%#08.8x)"), dwHelpID ) ;
  1145. WRITE1( str ) ;
  1146. }
  1147. }
  1148. else if (dwHelpID > 0)
  1149. {
  1150. WRITECR(",") ;
  1151. str.Format( _T("  helpcontext(%#08.8x)"), dwHelpID ) ;
  1152. WRITE1( str ) ;
  1153. }
  1154. }
  1156. // source, default, or restricted
  1157. if (pattr->wTypeFlags == TYPEFLAG_FHIDDEN)
  1158. {
  1159. WRITECR(",") ;
  1160. WRITE1("  hidden") ;
  1161. }
  1163. if (pattr->wTypeFlags == TYPEFLAG_FDUAL)
  1164. {
  1165. WRITECR(",") ;
  1166. WRITE1("  dual") ;
  1167. }
  1169. WRITECR("") ;
  1170. WRITELINE(_T("]")) ;
  1171. WRITE1(_T("dispinterface ")) ;
  1172. // interface name
  1173. WRITEBSTR( bstrName ) ;
  1175. if (bstrName)
  1176. SysFreeString( bstrName ) ;
  1177. if (bstrDoc)
  1178. SysFreeString( bstrDoc ) ;
  1179. if (bstrHelp)
  1180. SysFreeString( bstrHelp ) ;
  1181. bstrName = bstrDoc = bstrHelp = NULL ;
  1183. WRITECR(_T(" {")) ;
  1185. WRITELINE2(_T("properties:"), 1) ;
  1186. for (UINT n = 0 ; n < pattr->cVars ; n++)
  1187. DumpVar( pstm, pti, pattr, n, uiIndent + 2 ) ;
  1189. WRITELINE2(_T("methods:"), 1) ;
  1190. for (n = 0 ; n < pattr->cFuncs ; n++)
  1191. DumpFunc( pstm, pti, pattr, n, uiIndent + 2 ) ;
  1193. WRITELINE("};") ;
  1195. if (bstrName)
  1196. SysFreeString( bstrName ) ;
  1197. if (bstrDoc)
  1198. SysFreeString( bstrDoc ) ;
  1199. if (bstrHelp)
  1200. SysFreeString( bstrHelp ) ;
  1202. pti->ReleaseTypeAttr( pattr ) ;
  1203. }
  1204. CATCH(CException, pException)
  1205. {
  1206. if (ptiImpl)
  1207. ptiImpl->Release() ;
  1209. if (bstrName)
  1210. SysFreeString( bstrName ) ;
  1211. if (bstrDoc)
  1212. SysFreeString( bstrDoc ) ;
  1213. if (bstrHelp)
  1214. SysFreeString( bstrHelp ) ;
  1215. if (pattr)
  1216. pti->ReleaseTypeAttr( pattr ) ;
  1217. }
  1218. END_CATCH
  1219. return hr ;
  1220. }
  1222. //  [
  1223. //    attributes
  1224. //  ]
  1225. //  coclass classname {
  1226. //      [attributes2] [interface | dispinterface] interfacename;
  1227. //      ...
  1228. //  };
  1229. //
  1230. //  attributes
  1231. //      uuid, helpstring, helpcontext, licensed, version, and appobject
  1232. //
  1233. HRESULT CTypeLibODLView::DeCompileCoClass( IStream* pstm, ITypeInfo* pti, UINT uiIndent /* = 0 */ )
  1234. {
  1235. HRESULT     hr = S_OK ;
  1236. TYPEATTR*   pattr = NULL ;
  1237. BSTR            bstrName = NULL ;
  1238. BSTR            bstrDoc = NULL ;
  1239. BSTR            bstrHelp = NULL ;
  1240. DWORD           dwHelpID ;
  1241. ITypeInfo*      ptiImpl = NULL ;
  1242. TYPEATTR*       pattrImpl = NULL ;
  1244. TRY
  1245. {
  1246. if (FAILED(hr = pti->GetTypeAttr( &pattr)))
  1247. AfxThrowOleException( hr ) ;
  1249. WRITELINE(_T("[")) ;
  1251. TCHAR szGUID[64] ;
  1252. StringFromGUID2T( pattr->guid, szGUID, sizeof(szGUID) ) ;
  1253. WRITE1("  uuid(") ;
  1254. WRITE(szGUID) ;
  1255. WRITE(")") ;
  1257. // was version specified
  1258. if (pattr->wMajorVerNum || pattr->wMinorVerNum)
  1259. {
  1260. WRITECR(",") ;
  1261. CString str ;
  1262. str.Format(_T("  version(%d.%d)"), pattr->wMajorVerNum, pattr->wMinorVerNum) ;
  1263. WRITE1(str) ;
  1264. }
  1266. if (SUCCEEDED(pti->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp )))
  1267. {
  1268. CString str ;
  1269. if (bstrDoc && *bstrDoc)
  1270. {
  1271. WRITECR(",") ;
  1272. USES_CONVERSION;
  1273. LPCTSTR lpszDoc = OLE2CT(bstrDoc);
  1274. ::SysFreeString(bstrDoc);
  1275. bstrDoc = NULL;
  1276. str.Format( _T("  helpstring("%s")"), lpszDoc ) ;
  1277. WRITE1( str ) ;
  1278. if (dwHelpID > 0)
  1279. {
  1280. WRITECR(",") ;
  1281. str.Format( _T("  helpcontext(%#08.8x)"), dwHelpID ) ;
  1282. WRITE1( str ) ;
  1283. }
  1284. }
  1285. else if (dwHelpID > 0)
  1286. {
  1287. WRITECR(",") ;
  1288. str.Format( _T("  helpcontext(%#08.8x)"), dwHelpID ) ;
  1289. WRITE1( str ) ;
  1290. }
  1291. }
  1293. if (pattr->wTypeFlags == TYPEFLAG_FAPPOBJECT)
  1294. {
  1295. WRITECR(",") ;
  1296. WRITE1("  appobject") ;
  1297. }
  1298. if (pattr->wTypeFlags == TYPEFLAG_FHIDDEN)
  1299. {
  1300. WRITECR(",") ;
  1301. WRITE1("  hidden") ;
  1302. }
  1303. if (pattr->wTypeFlags == TYPEFLAG_FLICENSED)
  1304. {
  1305. WRITECR(",") ;
  1306. WRITE1("  licensed") ;
  1307. }
  1308. if (pattr->wTypeFlags == TYPEFLAG_FCONTROL)
  1309. {
  1310. WRITECR(",") ;
  1311. WRITE1("  control") ;
  1312. }
  1314. WRITECR("") ;
  1315. WRITELINE(_T("]")) ;
  1316. WRITE1(_T("coclass ")) ;
  1317. // coclass name
  1318. WRITEBSTR( bstrName ) ;
  1320. if (bstrName)
  1321. SysFreeString( bstrName ) ;
  1322. if (bstrDoc)
  1323. SysFreeString( bstrDoc ) ;
  1324. if (bstrHelp)
  1325. SysFreeString( bstrHelp ) ;
  1326. bstrName = bstrDoc = bstrHelp = NULL ;
  1328. WRITECR(_T(" {")) ;
  1330. //  [attributes2] [interface | dispinterface] interfacename;
  1331. for (UINT n = 0 ; n < pattr->cImplTypes ; n++)
  1332. {
  1333. HREFTYPE href = NULL ;
  1335. int impltype = NULL ;
  1336. if (FAILED(hr = pti->GetImplTypeFlags( n, &impltype )))
  1337. AfxThrowOleException(hr) ;
  1339. if (FAILED(hr = pti->GetRefTypeOfImplType(n, &href)))
  1340. AfxThrowOleException(hr) ;
  1342. if (FAILED(hr = pti->GetRefTypeInfo( href, &ptiImpl )))
  1343. AfxThrowOleException(hr) ;
  1345. if (FAILED(hr = ptiImpl->GetDocumentation( MEMBERID_NIL, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp )))
  1346. AfxThrowOleException(hr) ;
  1348. if (FAILED(hr = ptiImpl->GetTypeAttr( &pattrImpl)))
  1349. AfxThrowOleException( hr ) ;
  1351. WRITE2(_T(""), 1 ) ;
  1353. if (impltype)
  1354. {
  1355. WRITE(_T("[")) ;
  1356. BOOL    fComma = FALSE ;
  1357. if (impltype & IMPLTYPEFLAG_FDEFAULT)
  1358. {
  1359. WRITE(_T("default")) ;
  1360. fComma = TRUE ;
  1361. }
  1362. if (impltype & IMPLTYPEFLAG_FSOURCE)
  1363. {
  1364. if (fComma)
  1365. WRITE(_T(", ")) ;
  1366. WRITE(_T("source")) ;
  1367. fComma = TRUE ;
  1368. }
  1369. if (impltype & IMPLTYPEFLAG_FRESTRICTED)
  1370. {
  1371. if (fComma)
  1372. WRITE(_T(", ")) ;
  1373. WRITE(_T("restricted")) ;
  1374. }
  1376. WRITE(_T("] "));
  1377. }
  1379. if (pattrImpl->typekind == TKIND_INTERFACE)
  1380. WRITE(_T("interface ")) ;
  1382. if (pattrImpl->typekind == TKIND_DISPATCH)
  1383. WRITE(_T("dispinterface ")) ;
  1385. WRITE( bstrName ) ;
  1387. WRITECR(_T(";")) ;
  1389. SysFreeString( bstrName ) ;
  1390. bstrName = NULL ;
  1391. SysFreeString( bstrDoc ) ;
  1392. bstrDoc = NULL ;
  1393. SysFreeString( bstrHelp ) ;
  1394. bstrHelp = NULL ;
  1396. ptiImpl->ReleaseTypeAttr( pattrImpl ) ;
  1397. pattrImpl = NULL ;
  1399. ptiImpl->Release() ;
  1400. ptiImpl = NULL ;
  1401. }
  1403. WRITELINE("};") ;
  1405. if (bstrName)
  1406. SysFreeString( bstrName ) ;
  1407. if (bstrDoc)
  1408. SysFreeString( bstrDoc ) ;
  1409. if (bstrHelp)
  1410. SysFreeString( bstrHelp ) ;
  1412. pti->ReleaseTypeAttr( pattr ) ;
  1413. }
  1414. CATCH(CException, pException)
  1415. {
  1416. if (ptiImpl)
  1417. {
  1418. if (pattrImpl)
  1419. ptiImpl->ReleaseTypeAttr( pattrImpl ) ;
  1421. ptiImpl->Release() ;
  1422. }
  1423. if (bstrName)
  1424. SysFreeString( bstrName ) ;
  1425. if (bstrDoc)
  1426. SysFreeString( bstrDoc ) ;
  1427. if (bstrHelp)
  1428. SysFreeString( bstrHelp ) ;
  1429. if (pattr)
  1430. pti->ReleaseTypeAttr( pattr ) ;
  1432. THROW_LAST();
  1433. }
  1434. END_CATCH
  1435. return hr ;
  1437. }
  1439. HRESULT CTypeLibODLView::DeCompileFunc( IStream* pstm, ITypeInfo* pti, MEMBERID memid, UINT uiIndent /* = 0 */ )
  1440. {
  1441. HRESULT     hr = S_OK ;
  1442. TYPEATTR*   pattr = NULL ;
  1443. ASSERT(pti) ;
  1445. TRY
  1446. {
  1447. if (FAILED(hr = pti->GetTypeAttr( &pattr)))
  1448. AfxThrowOleException( hr ) ;
  1450. if (FAILED(hr = DumpFunc( pstm, pti, pattr, memid, uiIndent )))
  1451. AfxThrowOleException( hr ) ;
  1453. pti->ReleaseTypeAttr( pattr ) ;
  1454. }
  1455. CATCH(CException, pException)
  1456. {
  1457. if (pattr)
  1458. pti->ReleaseTypeAttr( pattr ) ;
  1460. THROW_LAST();
  1461. }
  1462. END_CATCH
  1464. return hr ;
  1465. }
  1467. HRESULT CTypeLibODLView::DumpFunc( IStream* pstm, ITypeInfo* pti, TYPEATTR* pattr, MEMBERID memid, UINT uiIndent /* = 0 */ )
  1468. {
  1469. HRESULT     hr = S_OK ;
  1470. FUNCDESC*   pfuncdesc = NULL ;
  1471. BSTR            rgbstrNames[MAX_NAMES] ;
  1472. BSTR            bstrName = NULL ;
  1473. BSTR            bstrDoc = NULL ;
  1474. BSTR            bstrHelp = NULL ;
  1475. DWORD           dwHelpID ;
  1476. ASSERT(pti) ;
  1478. for (UINT ui = 0 ; ui < MAX_NAMES ; ui++)
  1479. rgbstrNames[ui] = NULL ;
  1481. TRY
  1482. {
  1483. if (FAILED(hr = pti->GetFuncDesc( memid, &pfuncdesc )))
  1484. AfxThrowOleException( hr ) ;
  1486. // If pattr->typekind == TKIND_DISPATCH (dispinterface)
  1487. //    [attributes] returntype methname(params);
  1488. // where attributes can be
  1489. //      id(<id>), propput, propget,
  1490. //      propputref, bindable, defaultbind, displaybind,
  1491. //      requestedit, source, vararg, hidden, helpstring("<helpstring>"),
  1492. //      helpcontext(<id>)
  1493. //
  1494. // If pattr->typekind == TKIND_INTERFACE || TKIND_MODULE
  1495. //  [attributes] returntype [calling convention]  funcname(params);
  1496. // where attributes can be
  1497. //      restricted, bindable, defaultbind, displaybind,
  1498. //      requestedit, source, vararg, hidden, helpstring("<helpstring>"),
  1499. //      helpcontext(<id>)
  1500. // and calling convention can be
  1501. //      pascal, cdecl, stdcall
  1502. //
  1503. // Write [attributes]
  1504. //
  1505. BOOL    fAttributes = FALSE ;      // any attributes?
  1506. BOOL    fAttribute = FALSE ;       // at least one (insert ",")
  1507. WRITE1("") ;    // indent
  1508. CString str ;
  1509. if (pattr->typekind == TKIND_DISPATCH)
  1510. {
  1511. fAttributes = TRUE ;
  1512. fAttribute = TRUE ;
  1513. str.Format(_T("[id(%d)"), memid) ;
  1514. WRITE(str) ;
  1515. }
  1516. else if (pattr->typekind == TKIND_MODULE)
  1517. {
  1518. fAttributes = TRUE ;
  1519. fAttribute = TRUE ;
  1520. str.Format(_T("[entry(%d)"), memid) ;
  1521. WRITE(str) ;
  1522. }
  1523. else
  1524. // if there are some attributes
  1525. if ((pfuncdesc->invkind > 1)|| pfuncdesc->wFuncFlags || pfuncdesc->cParamsOpt == -1)
  1526. {
  1527. WRITE("[") ;
  1528. fAttributes = TRUE ;
  1529. }
  1531. if (pfuncdesc->invkind & INVOKE_PROPERTYGET)
  1532. {
  1533. if (fAttribute)
  1534. WRITE(", ") ;
  1535. fAttribute = TRUE ;
  1536. WRITE("propget") ;
  1537. }
  1538. if (pfuncdesc->invkind & INVOKE_PROPERTYPUT)
  1539. {
  1540. if (fAttribute)
  1541. WRITE(", ") ;
  1542. fAttribute = TRUE ;
  1543. WRITE("propput") ;
  1544. }
  1545. if (pfuncdesc->invkind & INVOKE_PROPERTYPUTREF)
  1546. {
  1547. if (fAttribute)
  1548. WRITE(", ") ;
  1549. fAttribute = TRUE ;
  1550. WRITE("propputref") ;
  1551. }
  1552. if (pfuncdesc->wFuncFlags & FUNCFLAG_FRESTRICTED)
  1553. {
  1554. if (fAttribute)
  1555. WRITE(", ") ;
  1556. fAttribute = TRUE ;
  1557. WRITE("restricted") ;
  1558. }
  1559. if (pfuncdesc->wFuncFlags & FUNCFLAG_FSOURCE)
  1560. {
  1561. if (fAttribute)
  1562. WRITE(", ") ;
  1563. fAttribute = TRUE ;
  1564. WRITE("source") ;
  1565. }
  1566. if (pfuncdesc->wFuncFlags & FUNCFLAG_FBINDABLE)
  1567. {
  1568. if (fAttribute)
  1569. WRITE(", ") ;
  1570. fAttribute = TRUE ;
  1571. WRITE("bindable") ;
  1572. }
  1573. if (pfuncdesc->wFuncFlags & FUNCFLAG_FREQUESTEDIT)
  1574. {
  1575. if (fAttribute)
  1576. WRITE(", ") ;
  1577. fAttribute = TRUE ;
  1578. WRITE("requestedit") ;
  1579. }
  1580. if (pfuncdesc->wFuncFlags & FUNCFLAG_FDISPLAYBIND)
  1581. {
  1582. if (fAttribute)
  1583. WRITE(", ") ;
  1584. fAttribute = TRUE ;
  1585. WRITE("displaybind") ;
  1586. }
  1587. if (pfuncdesc->wFuncFlags & FUNCFLAG_FDEFAULTBIND)
  1588. {
  1589. if (fAttribute)
  1590. WRITE(", ") ;
  1591. fAttribute = TRUE ;
  1592. WRITE("defaultbind") ;
  1593. }
  1594. if (pfuncdesc->wFuncFlags & FUNCFLAG_FHIDDEN)
  1595. {
  1596. if (fAttribute)
  1597. WRITE(", ") ;
  1598. fAttribute = TRUE ;
  1599. WRITE("hidden") ;
  1600. }
  1601. if (pfuncdesc->cParamsOpt == -1)    // cParamsOpt > 0 indicates VARIANT style
  1602. {
  1603. if (fAttribute)
  1604. WRITE(", ") ;
  1605. fAttribute = TRUE ;
  1606. WRITE("vararg") ;         // optional params
  1607. }
  1609. if (SUCCEEDED(pti->GetDocumentation( pfuncdesc->memid, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp )))
  1610. {
  1611. CString str ;
  1612. if (bstrDoc && *bstrDoc)
  1613. {
  1614. if (fAttributes == FALSE) WRITE("[") ;
  1615. fAttributes = TRUE ;
  1616. if (fAttribute)
  1617. WRITE(", ") ;
  1618. USES_CONVERSION;
  1619. LPCTSTR lpszDoc = OLE2CT(bstrDoc);
  1620. ::SysFreeString(bstrDoc);
  1621. bstrDoc = NULL;
  1622. str.Format( _T("helpstring("%s")"), lpszDoc ) ;
  1623. WRITE( str ) ;
  1624. if (dwHelpID > 0)
  1625. {
  1626. str.Format( _T(", helpcontext(%#08.8x)"), dwHelpID ) ;
  1627. WRITE( str ) ;
  1628. }
  1629. }
  1630. else if (dwHelpID > 0)
  1631. {
  1632. if (fAttributes == FALSE) WRITE("[") ;
  1633. if (fAttribute)
  1634. WRITE(", ") ;
  1635. fAttributes = TRUE ;
  1636. str.Format( _T("helpcontext(%#08.8x)"), dwHelpID ) ;
  1637. WRITE( str ) ;
  1638. }
  1639. }
  1640. if (fAttributes)
  1641. WRITE("] ") ;
  1643. // Write return type
  1644. WRITE(TYPEDESCtoString( pti, &pfuncdesc->elemdescFunc.tdesc )) ;
  1645. WRITE(" ") ;
  1647. if (pattr->typekind != TKIND_DISPATCH)
  1648. {   // Write calling convention
  1649. switch(pfuncdesc->callconv)
  1650. {
  1651. case CC_CDECL:      WRITE("_cdecl ") ;           break ;
  1652. //case CC_MSCPASCAL:  WRITE("_mspascal ") ;        break ;
  1653. case CC_PASCAL:     WRITE("_pascal ") ;          break ;
  1654. case CC_MACPASCAL:  WRITE("_macpascal ") ;       break ;
  1655. case CC_STDCALL :   WRITE("_stdcall ") ;          break ;
  1656. //case CC_RESERVED:   WRITE("_reserved ") ;         break ;
  1657. case CC_SYSCALL:    WRITE("_syscall ") ;          break ;
  1658. case CC_MPWCDECL:   WRITE("_mpwcdecl ") ;         break ;
  1659. case CC_MPWPASCAL:  WRITE("_mpwpascal ") ;        break ;
  1660. }
  1661. }
  1663. // Write methodname
  1665. // HACK:  If a property has the propput or propputref attributes the
  1666. // 'right hand side' (rhs) is *always* the last parameter and MkTypeLib
  1667. // strips the parameter name.  Thus you will always get 1 less name
  1668. // back from ::GetNames than normal.
  1669. //
  1670. // Thus for the example below
  1671. //  [propput] void Color([in] VARIANT rgb, [in] VARIANT rgb2 );
  1672. // without taking this into consderation the output would be
  1673. //  [propput] void Color([in] VARIANT rgb, [in] VARIANT );
  1674. // when it should be
  1675. //  [propput] void Color([in] VARIANT rgb, [in] VARIANT rhs );
  1676. //
  1677. // Another weirdness comes from a bug (which will never be fixed)
  1678. // where optional parameters on property functions were allowed.
  1679. // Because they were allowed by accident people used them, so they
  1680. // are still allowed.
  1681. //
  1683. UINT cNames = 0 ;
  1684. if (FAILED( hr = pti->GetNames( pfuncdesc->memid, rgbstrNames, MAX_NAMES, &cNames )))
  1685. AfxThrowOleException( hr ) ;
  1687. // fix for 'rhs' problem
  1688. if ((int)cNames < pfuncdesc->cParams + 1)
  1689. {
  1690. rgbstrNames[cNames] = ::SysAllocString(OLESTR("rhs")) ;
  1691. cNames++ ;
  1692. }
  1694. ASSERT((int)cNames == pfuncdesc->cParams+1) ;
  1695. WRITEBSTR( rgbstrNames[0] ) ;
  1696. WRITE("(") ;
  1698. // params have the format
  1699. //   [attributes] type paramname
  1700. // where attributes can be
  1701. //   in, out, optional, string   (string is not valid for TKIND_MODULE)
  1702. //
  1703. if (pfuncdesc->cParams > 1)
  1704. WRITECR("") ;
  1705. for ( int n = 0 ; n < pfuncdesc->cParams ; n++ )
  1706. {
  1707. if (pfuncdesc->cParams > 1)
  1708. WRITE2("", 4 ) ;    // indent 4
  1709. fAttributes = FALSE ;
  1710. fAttribute = FALSE ;
  1712. if (pfuncdesc->lprgelemdescParam[n].idldesc.wIDLFlags)
  1713. {
  1714. WRITE("[") ;
  1715. fAttributes = TRUE ;
  1716. }
  1718. if (pfuncdesc->lprgelemdescParam[n].idldesc.wIDLFlags & IDLFLAG_FIN)
  1719. {
  1720. if (fAttribute)
  1721. WRITE(", ") ;
  1722. WRITE("in") ;
  1723. fAttribute = TRUE ;
  1724. }
  1725. if (pfuncdesc->lprgelemdescParam[n].idldesc.wIDLFlags & IDLFLAG_FOUT)
  1726. {
  1727. if (fAttribute)
  1728. WRITE(", ") ;
  1729. WRITE("out") ;
  1730. fAttribute = TRUE ;
  1731. }
  1732. if (pfuncdesc->lprgelemdescParam[n].idldesc.wIDLFlags & IDLFLAG_FLCID)
  1733. {
  1734. if (fAttribute)
  1735. WRITE(", ") ;
  1736. WRITE("lcid") ;
  1737. fAttribute = TRUE ;
  1738. }
  1739. if (pfuncdesc->lprgelemdescParam[n].idldesc.wIDLFlags & IDLFLAG_FRETVAL)
  1740. {
  1741. if (fAttribute)
  1742. WRITE(", ") ;
  1743. WRITE("retval") ;
  1744. fAttribute = TRUE ;
  1745. }
  1747. // If we have an optional last parameter and we're on the last paramter
  1748. // or we are into the optional parameters...
  1749. if ((pfuncdesc->cParamsOpt == -1 && n == pfuncdesc->cParams - 1) ||
  1750. (n > (pfuncdesc->cParams - pfuncdesc->cParamsOpt)))
  1751. {
  1752. if (fAttribute)
  1753. WRITE(", ") ;
  1754. if (!fAttributes)
  1755. WRITE("[") ;
  1756. WRITE("optional") ;
  1757. fAttributes = TRUE ;
  1758. fAttribute = TRUE ;
  1759. }
  1761. if (fAttributes)
  1762. WRITE("] ") ;
  1764. // type
  1765. CString str ;
  1766. if ((pfuncdesc->lprgelemdescParam[n].tdesc.vt & 0x0FFF) == VT_CARRAY)
  1767. {
  1768. // type name[n]
  1769. WRITE(TYPEDESCtoString( pti, &pfuncdesc->lprgelemdescParam[n].tdesc.lpadesc->tdescElem )) ;
  1770. WRITE(" ") ;
  1772. WRITEBSTR(rgbstrNames[n+1]) ;
  1774. // Allocate cDims * lstrlen("[123456]")
  1775. for (USHORT n = 0 ; n < pfuncdesc->lprgelemdescParam[n].tdesc.lpadesc->cDims ; n++)
  1776. {
  1777. str.Format( _T("[%d]"), pfuncdesc->lprgelemdescParam[n].tdesc.lpadesc->rgbounds[n].cElements ) ;
  1778. WRITE(str) ;
  1779. }
  1780. }
  1781. else
  1782. {
  1783. WRITE(TYPEDESCtoString( pti, &pfuncdesc->lprgelemdescParam[n].tdesc ) + " " ) ;
  1784. WRITEBSTR(rgbstrNames[n+1]) ;
  1785. }
  1786. if (n < pfuncdesc->cParams - 1)
  1787. WRITECR(", ") ;
  1788. }
  1790. WRITECR(");") ;
  1792. for (UINT ui = 0 ; ui < MAX_NAMES ; ui++)
  1793. if (rgbstrNames[ui])
  1794. SysFreeString(rgbstrNames[ui]) ;
  1795. if (bstrName)
  1796. SysFreeString( bstrName ) ;
  1797. if (bstrDoc)
  1798. SysFreeString( bstrDoc ) ;
  1799. if (bstrHelp)
  1800. SysFreeString( bstrHelp ) ;
  1802. pti->ReleaseFuncDesc( pfuncdesc ) ;
  1803. }
  1804. CATCH(CException, pException)
  1805. {
  1806. for (UINT ui = 0 ; ui < MAX_NAMES ; ui++)
  1807. if (rgbstrNames[ui])
  1808. SysFreeString(rgbstrNames[ui]) ;
  1810. if (bstrName)
  1811. SysFreeString( bstrName ) ;
  1812. if (bstrDoc)
  1813. SysFreeString( bstrDoc ) ;
  1814. if (bstrHelp)
  1815. SysFreeString( bstrHelp ) ;
  1816. if (pfuncdesc)
  1817. pti->ReleaseFuncDesc( pfuncdesc ) ;
  1819. THROW_LAST();
  1820. }
  1821. END_CATCH
  1823. return hr ;
  1824. }
  1826. HRESULT CTypeLibODLView::DeCompileVar( IStream* pstm, ITypeInfo* pti, MEMBERID memid, UINT uiIndent /* = 0 */)
  1827. {
  1828. HRESULT     hr = S_OK ;
  1829. TYPEATTR*   pattr = NULL ;
  1830. ASSERT(pti) ;
  1832. TRY
  1833. {
  1834. if (FAILED(hr = pti->GetTypeAttr( &pattr)))
  1835. AfxThrowOleException( hr ) ;
  1837. if (FAILED(hr = DumpVar( pstm, pti, pattr, memid, uiIndent )))
  1838. AfxThrowOleException( hr ) ;
  1840. pti->ReleaseTypeAttr( pattr ) ;
  1841. }
  1842. CATCH(CException, pException)
  1843. {
  1844. if (pattr)
  1845. pti->ReleaseTypeAttr( pattr ) ;
  1847. THROW_LAST();
  1848. }
  1849. END_CATCH
  1851. return hr ;
  1852. }
  1854. HRESULT CTypeLibODLView::DumpVar( IStream* pstm, ITypeInfo* pti, TYPEATTR* pattr, MEMBERID memid, UINT uiIndent /* = 0 */)
  1855. {
  1856. HRESULT     hr = S_OK ;
  1857. VARDESC*    pvardesc = NULL ;
  1858. BSTR            rgbstrNames[1] ;
  1859. BSTR            bstrName = NULL ;
  1860. BSTR            bstrDoc = NULL ;
  1861. BSTR            bstrHelp = NULL ;
  1862. DWORD           dwHelpID ;
  1863. ASSERT(pti) ;
  1865. TRY
  1866. {
  1867. if (FAILED(hr = pti->GetVarDesc( memid, &pvardesc )))
  1868. AfxThrowOleException( hr ) ;
  1870. ASSERT(pvardesc->varkind != VAR_CONST) ;    // must not be a const
  1872. // If pattr->typekind == TKIND_RECORD (struct) || TKIND_UNION
  1873. //    type name[array];
  1874. //
  1875. // If pattr->typekind == TKIND_DISPATCH (dispinterface)
  1876. //    [id(<id>), bindable, defaultbind, displaybind, readonly,
  1877. //      requestedit, source, hidden, helpstring("<helpstring>"),
  1878. //      helpcontext(<id>)] type name;
  1879. //
  1880. BOOL    fAttributes = FALSE ;
  1881. WRITE1("") ;    // indent
  1882. if (pattr->typekind == TKIND_DISPATCH)
  1883. {
  1884. CString str ;
  1885. fAttributes = TRUE ;
  1886. str.Format(_T("[id(%d)"), memid) ;
  1887. WRITE(str) ;
  1889. if (pvardesc->wVarFlags & VARFLAG_FREADONLY)
  1890. WRITE(", readonly") ;
  1891. if (pvardesc->wVarFlags & VARFLAG_FSOURCE)
  1892. WRITE(", source") ;
  1893. if (pvardesc->wVarFlags & VARFLAG_FBINDABLE)
  1894. WRITE(", bindable") ;
  1895. if (pvardesc->wVarFlags & VARFLAG_FREQUESTEDIT)
  1896. WRITE(", requestedit") ;
  1897. if (pvardesc->wVarFlags & VARFLAG_FDISPLAYBIND)
  1898. WRITE(", displaybind") ;
  1899. if (pvardesc->wVarFlags & VARFLAG_FDEFAULTBIND)
  1900. WRITE(", defaultbind") ;
  1901. if (pvardesc->wVarFlags & VARFLAG_FHIDDEN)
  1902. WRITE(", hidden") ;
  1903. }
  1905. if (SUCCEEDED(pti->GetDocumentation( pvardesc->memid, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp )))
  1906. {
  1907. CString str ;
  1908. if (bstrDoc && *bstrDoc)
  1909. {
  1910. if (fAttributes == FALSE)
  1911. WRITE("[") ;
  1912. else
  1913. WRITE(", ") ;
  1914. fAttributes = TRUE ;
  1915. USES_CONVERSION;
  1916. LPCTSTR lpszDoc = OLE2CT(bstrDoc);
  1917. ::SysFreeString(bstrDoc);
  1918. bstrDoc = NULL;
  1919. str.Format( _T("helpstring("%s")"), lpszDoc ) ;
  1920. WRITE( str ) ;
  1921. if (dwHelpID > 0)
  1922. {
  1923. str.Format( _T(", helpcontext(%#08.8x)"), dwHelpID ) ;
  1924. WRITE( str ) ;
  1925. }
  1926. }
  1927. else if (dwHelpID > 0)
  1928. {
  1929. if (fAttributes == FALSE)
  1930. WRITE("[") ;
  1931. else
  1932. WRITE(", ") ;
  1933. fAttributes = TRUE ;
  1934. str.Format( _T("helpcontext(%#08.8x)"), dwHelpID ) ;
  1935. WRITE( str ) ;
  1936. }
  1937. }
  1939. if (fAttributes)
  1940. WRITE("] ") ;
  1941. UINT cNames ;
  1942. if (FAILED( hr = pti->GetNames( pvardesc->memid, rgbstrNames, 1, (UINT FAR*)&cNames )))
  1943. AfxThrowOleException( hr ) ;
  1945. CString str ;
  1946. if ((pvardesc->elemdescVar.tdesc.vt & 0x0FFF) == VT_CARRAY)
  1947. {
  1948. // type name[n]
  1949. WRITE(TYPEDESCtoString( pti, &pvardesc->elemdescVar.tdesc.lpadesc->tdescElem )) ;
  1950. WRITE(" ") ;
  1951. if (rgbstrNames[0])
  1952. WRITEBSTR(rgbstrNames[0]);
  1953. else
  1954. WRITE(_T("(nameless)")) ;
  1955. // Allocate cDims * lstrlen("[123456]")
  1956. for (USHORT n = 0 ; n < pvardesc->elemdescVar.tdesc.lpadesc->cDims ; n++)
  1957. {
  1958. str.Format( _T("[%d]"), pvardesc->elemdescVar.tdesc.lpadesc->rgbounds[n].cElements ) ;
  1959. WRITE(str) ;
  1960. }
  1961. }
  1962. else
  1963. {
  1964. WRITE(TYPEDESCtoString( pti, &pvardesc->elemdescVar.tdesc ) + _T(" "));
  1965. if (rgbstrNames[0])
  1966. WRITEBSTR(rgbstrNames[0]);
  1967. else
  1968. WRITE(_T("(nameless)")) ;
  1969. }
  1970. WRITECR(";") ;
  1972. if (bstrName)
  1973. SysFreeString( bstrName ) ;
  1974. if (bstrDoc)
  1975. SysFreeString( bstrDoc ) ;
  1976. if (bstrHelp)
  1977. SysFreeString( bstrHelp ) ;
  1979. pti->ReleaseVarDesc( pvardesc ) ;
  1980. }
  1981. CATCH(CException, pException)
  1982. {
  1983. if (bstrName)
  1984. SysFreeString( bstrName ) ;
  1985. if (bstrDoc)
  1986. SysFreeString( bstrDoc ) ;
  1987. if (bstrHelp)
  1988. SysFreeString( bstrHelp ) ;
  1989. if (pvardesc)
  1990. pti->ReleaseVarDesc( pvardesc ) ;
  1992. THROW_LAST();
  1993. }
  1994. END_CATCH
  1996. return hr ;
  1997. }
  1999. // if fConst ==  TURE
  2000. //  const type name = value ;
  2001. // else
  2002. //  name = value  (no commas)
  2003. //
  2004. HRESULT CTypeLibODLView::DeCompileConst( IStream* pstm, ITypeInfo* pti, MEMBERID memid, UINT uiIndent /* = 0 */, BOOL fConst /* = TRUE */  )
  2005. {
  2006. HRESULT     hr = S_OK ;
  2007. TYPEATTR*       pattr = NULL ;
  2008. ASSERT(pti) ;
  2010. TRY
  2011. {
  2012. if (FAILED(hr = pti->GetTypeAttr( &pattr)))
  2013. AfxThrowOleException( hr ) ;
  2015. if (FAILED(hr = DumpConst( pstm, pti, pattr, memid, uiIndent, fConst )))
  2016. AfxThrowOleException( hr ) ;
  2018. pti->ReleaseTypeAttr( pattr ) ;
  2019. }
  2020. CATCH(CException, pException)
  2021. {
  2022. if (pattr)
  2023. pti->ReleaseTypeAttr( pattr ) ;
  2024. THROW_LAST();
  2025. }
  2026. END_CATCH
  2028. return hr ;
  2029. }
  2031. HRESULT CTypeLibODLView::DumpConst( IStream* pstm, ITypeInfo* pti, TYPEATTR* pattr, MEMBERID memid, UINT uiIndent /* = 0 */, BOOL fConst /* = TRUE */  )
  2032. {
  2033. USES_CONVERSION;
  2034. HRESULT     hr = S_OK ;
  2035. VARDESC*    pvardesc = NULL ;
  2036. BSTR            rgbstrNames[1] ;
  2037. BSTR            bstrName = NULL ;
  2038. BSTR            bstrDoc = NULL ;
  2039. BSTR            bstrHelp = NULL ;
  2040. DWORD           dwHelpID ;
  2041. ASSERT(pti) ;
  2042. VARIANT varValue ;
  2043. VariantInit( &varValue ) ;
  2045. TRY
  2046. {
  2047. if (FAILED(hr = pti->GetVarDesc( memid, &pvardesc )))
  2048. AfxThrowOleException( hr ) ;
  2050. ASSERT(pvardesc->varkind == VAR_CONST) ;
  2052. CString str = TYPEDESCtoString( pti, &pvardesc->elemdescVar.tdesc ) ;
  2053. if (FAILED(hr = VariantChangeType( &varValue, pvardesc->lpvarValue, 0, VT_BSTR )))
  2054. {
  2055. if (pvardesc->lpvarValue->vt == VT_ERROR || pvardesc->lpvarValue->vt == VT_HRESULT)
  2056. {
  2057. varValue.vt = VT_BSTR ;
  2058. varValue.bstrVal = ::SysAllocString(T2OLE(_GetScodeString(pvardesc->lpvarValue->scode))) ;
  2059. hr = S_OK ;
  2060. }
  2061. else
  2062. AfxThrowOleException( hr ) ;
  2063. }
  2065. BOOL fIndent = FALSE ;
  2066. if (fConst)
  2067. {
  2068. CString str ;
  2069. if (pattr->typekind == TKIND_MODULE)
  2070. {
  2071. str.Format(_T("[entry(%d)"), memid) ;
  2072. WRITE1(str) ;
  2073. fIndent = TRUE ;
  2074. }
  2076. // [helpstring("<helpstring>"), helpcontext(<id>)] const type name = expression ;
  2077. if (SUCCEEDED(pti->GetDocumentation( pvardesc->memid, &bstrName, &bstrDoc, &dwHelpID, &bstrHelp )))
  2078. {
  2079. if (bstrDoc && *bstrDoc)
  2080. {
  2081. if (!fIndent)
  2082. WRITE1("[") ;
  2083. else
  2084. WRITE(", ") ;
  2085. LPCTSTR lpszDoc = OLE2CT(bstrDoc);
  2086. ::SysFreeString(bstrDoc);
  2087. bstrDoc = NULL;
  2088. str.Format( _T("helpstring("%s")"), lpszDoc ) ;
  2089. WRITE( str ) ;
  2090. if (dwHelpID > 0)
  2091. {
  2092. str.Format( _T(", helpcontext(%#08.8x)"), dwHelpID ) ;
  2093. WRITE( str ) ;
  2094. }
  2095. WRITE("] ");
  2096. fIndent = TRUE ;
  2097. }
  2098. else if (dwHelpID > 0)
  2099. {
  2100. if (!fIndent)
  2101. WRITE1("[") ;
  2102. else
  2103. WRITE(", ") ;
  2104. str.Format( _T("helpcontext(%#08.8x)] "), dwHelpID ) ;
  2105. WRITE( str ) ;
  2106. fIndent = TRUE ;
  2107. }
  2108. }
  2109. }
  2111. UINT cNames ;
  2112. if (FAILED( hr = pti->GetNames( pvardesc->memid, rgbstrNames, 1, (UINT FAR*)&cNames )))
  2113. AfxThrowOleException( hr ) ;
  2115. if (fConst)
  2116. {
  2117. if (!fIndent)
  2118. WRITE1(_T("")) ;
  2119. WRITE("const ") ; WRITE( str ) ; WRITE( " " ) ;
  2120. }
  2121. else
  2122. WRITE1("") ;
  2124. WRITEBSTR( rgbstrNames[0] ) ; WRITE( " = " ) ;
  2126. if (pvardesc->lpvarValue->vt == VT_BSTR)
  2127. {
  2128. WRITE( """ ) ;
  2129. WRITEBSTR( varValue.bstrVal ) ;
  2130. WRITE( """ ) ;
  2131. }
  2132. else
  2133. WRITEBSTR( varValue.bstrVal) ;
  2135. if (fConst)
  2136. WRITECR(";") ;
  2138. VariantClear( &varValue ) ;
  2140. if (bstrName)
  2141. SysFreeString( bstrName ) ;
  2142. if (bstrDoc)
  2143. SysFreeString( bstrDoc ) ;
  2144. if (bstrHelp)
  2145. SysFreeString( bstrHelp ) ;
  2146. pti->ReleaseVarDesc( pvardesc ) ;
  2147. }
  2148. CATCH(CException, pException)
  2149. {
  2150. VariantClear( &varValue ) ;
  2151. if (bstrName)
  2152. SysFreeString( bstrName ) ;
  2153. if (bstrDoc)
  2154. SysFreeString( bstrDoc ) ;
  2155. if (bstrHelp)
  2156. SysFreeString( bstrHelp ) ;
  2157. if (pvardesc)
  2158. pti->ReleaseVarDesc( pvardesc ) ;
  2160. THROW_LAST();
  2161. }
  2162. END_CATCH
  2164. return hr ;
  2165. }
  2167. IStream* CreateMemoryStream()
  2168. {
  2169. LPSTREAM lpStream = NULL;
  2171. // Create a stream object on a memory block.
  2172. HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE, 0);
  2173. if (hGlobal != NULL)
  2174. {
  2175. HRESULT hr ;
  2176. if (FAILED(hr = CreateStreamOnHGlobal(hGlobal, TRUE, &lpStream)))
  2177. {
  2178. TRACE0("CreateStreamOnHGlobal failed.n");
  2179. GlobalFree(hGlobal);
  2180. AfxThrowOleException( hr ) ;
  2181. }
  2182. }
  2183. else
  2184. {
  2185. TRACE0("Failed to allocate memory for stream.n");
  2186. AfxThrowMemoryException() ;
  2187. }
  2189. return lpStream;
  2190. }
  2192. int StringFromGUID2T(REFGUID rguid, LPTSTR lpszGUID, int cbMax )
  2193. {
  2194. USES_CONVERSION;
  2195. OLECHAR* lpszOle = (OLECHAR*)_alloca(cbMax*sizeof(OLECHAR));
  2196. int nCount = ::StringFromGUID2(rguid,lpszOle, cbMax*sizeof(OLECHAR));
  2197. if (nCount == 0)
  2198. {
  2199. lpszGUID[0] = '';
  2200. return 0; // buffer too small for the returned string
  2201. }
  2202. LPTSTR lpszRes = OLE2T(lpszOle);
  2203. lstrcpy(lpszGUID, lpszRes);
  2204. return 0;
  2205. }