home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 40 / IOPROG_40.ISO / SOFT / NETFrameworkSDK.exe / comsdk.cab / samples1.exe / smc / CORwrap.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-23  |  64.2 KB  |  2,119 lines
  1. #include <stdio.h>
  2. #include <assert.h>
  3. #include <windows.h>
  4.  
  5. /*****************************************************************************/
  6.  
  7. #define COR_IMPORT(d,s) __declspec(dllexport)
  8.  
  9. #include <COR.h>
  10. #include <CorSym.h>
  11.  
  12. #include "CORwrap.h"
  13.  
  14. /*****************************************************************************/
  15.  
  16. #if 0
  17.  
  18. const   unsigned    META_S_DUPLICATE  = 0x131197;
  19.  
  20. void                logCall(int err, const char *name)
  21. {
  22.     static
  23.     bool            doit;
  24.     static
  25.     bool            init;
  26.     static
  27.     unsigned        ord;
  28.  
  29.     if  (!init)
  30.     {
  31.         init = true;
  32.         doit = getenv("LOGMD") ? true : false;
  33.     }
  34.  
  35.     if  (err && err != 1 && err != META_S_DUPLICATE)
  36.         printf("WARNING: Error %08X returned from metadata API '%s'\n", err, name);
  37.  
  38. #ifndef __IL__
  39.     if (++ord == 0x0) __asm int 3
  40. #endif
  41.  
  42.     if  (!doit)
  43.         return;
  44.  
  45. #ifndef __IL__
  46.     printf("[%04X] ", ord);
  47. #endif
  48.  
  49.     if      (err == -1)
  50.         printf("Return(-1)");
  51.     else if (err == 0)
  52.         printf("Return(OK)");
  53.     else if (err == 1)
  54.         printf("Return(N/A)");
  55.     else if (err == META_S_DUPLICATE)
  56.         printf("Return(dup)");
  57.     else
  58.         printf("Return(0x%X)", err);
  59.  
  60.     printf(" from '%s'\n", name);
  61. }
  62.  
  63. #else
  64.  
  65. inline
  66. void                logCall(int err, const char *name){}
  67.  
  68. #endif
  69.  
  70. /*****************************************************************************/
  71.  
  72. bool                CORinitialized;
  73.  
  74. /*****************************************************************************/
  75.  
  76. void                WMetaData::AddRef (){}
  77. void                WMetaData::Release(){}
  78.  
  79. /*****************************************************************************/
  80.  
  81. const GUID*__stdcall getIID_CorMetaDataRuntime()      { return &CLSID_CorMetaDataRuntime;    }
  82.  
  83. const GUID*__stdcall getIID_IMetaDataImport()         { return &IID_IMetaDataImport;         }
  84. const GUID*__stdcall getIID_IMetaDataEmit()           { return &IID_IMetaDataEmit;           }
  85.  
  86. const GUID*__stdcall getIID_IMetaDataAssemblyImport() { return &IID_IMetaDataAssemblyImport; }
  87. const GUID*__stdcall getIID_IMetaDataAssemblyEmit()   { return &IID_IMetaDataAssemblyEmit;   }
  88.  
  89. /*****************************************************************************/
  90.  
  91. struct  intfListRec;
  92. typedef intfListRec*IntfList;
  93. struct  intfListRec
  94. {
  95.     IntfList        ilNext;
  96.     void        *   ilIntf;
  97.     WMetaData   *   ilWrap;
  98. };
  99.  
  100. IntfList            IMDDlist;
  101. IntfList            IMDIlist;
  102. IntfList            IMDElist;
  103. IntfList            IASIlist;
  104. IntfList            IASElist;
  105.  
  106. IntfList            SYMWlist;
  107.  
  108. WMetaData   *       findIntfListEntry(IntfList list, void *intf)
  109. {
  110.     IntfList        temp;
  111.  
  112.     for (temp = list; temp; temp = temp->ilNext)
  113.     {
  114.         if  (temp->ilIntf == intf)
  115.             return  temp->ilWrap;
  116.     }
  117.  
  118.     return  NULL;
  119. }
  120.  
  121. void                 addIntfListEntry(IntfList &list, void *intf, WMetaData *wrap)
  122. {
  123.     IntfList        temp;
  124.  
  125.     temp = new intfListRec;
  126.     temp->ilIntf = intf;
  127.     temp->ilWrap = wrap;
  128.     temp->ilNext = list;
  129.                    list = temp;
  130. }
  131.  
  132. /*****************************************************************************/
  133.  
  134. WMetaDataDispenser *  __stdcall makeIMDDwrapper(IMetaDataDispenser *intf)
  135. {
  136.     WMetaDataDispenser *wrap;
  137.     WMetaData          *oldw;
  138.  
  139.     oldw = findIntfListEntry(IMDDlist, intf);
  140.     if  (oldw)
  141.         return  dynamic_cast<WMetaDataDispenser *>(oldw);
  142.  
  143.     wrap = new WMetaDataDispenser;
  144.  
  145.     wrap->useCount = 1;
  146.     wrap->imdd     = intf;
  147.  
  148.     addIntfListEntry(IMDDlist, intf, wrap);
  149.  
  150.     return  wrap;
  151. }
  152.  
  153. WMetaDataImport    *  __stdcall makeIMDIwrapper(IMetaDataImport    *intf)
  154. {
  155.     WMetaDataImport    *wrap;
  156.     WMetaData          *oldw;
  157.  
  158.     oldw = findIntfListEntry(IMDIlist, intf);
  159.     if  (oldw)
  160.         return  dynamic_cast<WMetaDataImport    *>(oldw);
  161.  
  162.     wrap = new WMetaDataImport;
  163.  
  164.     wrap->useCount = 1;
  165.     wrap->imdi     = intf;
  166.  
  167. #ifdef SMC_MD_PERF
  168.     wrap->cycleCounterInit();
  169.     wrap->cycleCounterBeg();
  170.     wrap->cycleCounterPause();
  171. #endif
  172.  
  173.     addIntfListEntry(IMDIlist, intf, wrap);
  174.  
  175.     return  wrap;
  176. }
  177.  
  178. WMetaDataEmit      *  __stdcall makeIMDEwrapper(IMetaDataEmit      *intf)
  179. {
  180.     WMetaDataEmit      *wrap;
  181.     WMetaData          *oldw;
  182.  
  183.     oldw = findIntfListEntry(IMDElist, intf);
  184.     if  (oldw)
  185.         return  dynamic_cast<WMetaDataEmit      *>(oldw);
  186.  
  187.     wrap = new WMetaDataEmit;
  188.  
  189.     wrap->useCount = 1;
  190.     wrap->imde     = intf;
  191.  
  192. #ifdef SMC_MD_PERF
  193.     wrap->cycleCounterInit();
  194.     wrap->cycleCounterBeg();
  195.     wrap->cycleCounterPause();
  196. #endif
  197.  
  198.     addIntfListEntry(IMDElist, intf, wrap);
  199.  
  200.     return  wrap;
  201. }
  202.  
  203. WAssemblyImport    *  __stdcall makeIASIwrapper(IMetaDataAssemblyImport*intf)
  204. {
  205.     WAssemblyImport    *wrap;
  206.     WMetaData          *oldw;
  207.  
  208.     oldw = findIntfListEntry(IASIlist, intf);
  209.     if  (oldw)
  210.         return  dynamic_cast<WAssemblyImport    *>(oldw);
  211.  
  212.     wrap = new WAssemblyImport;
  213.  
  214.     wrap->useCount = 1;
  215.     wrap->iasi     = intf;
  216.  
  217. #ifdef SMC_MD_PERF
  218.     wrap->cycleCounterInit();
  219.     wrap->cycleCounterBeg();
  220.     wrap->cycleCounterPause();
  221. #endif
  222.  
  223.     addIntfListEntry(IASIlist, intf, wrap);
  224.  
  225.     return  wrap;
  226. }
  227.  
  228. WAssemblyEmit      *  __stdcall makeIASEwrapper(IMetaDataAssemblyEmit  *intf)
  229. {
  230.     WAssemblyEmit      *wrap;
  231.     WMetaData          *oldw;
  232.  
  233.     oldw = findIntfListEntry(IASElist, intf);
  234.     if  (oldw)
  235.         return  dynamic_cast<WAssemblyEmit      *>(oldw);
  236.  
  237.     wrap = new WAssemblyEmit;
  238.  
  239.     wrap->useCount = 1;
  240.     wrap->iase     = intf;
  241.  
  242. #ifdef SMC_MD_PERF
  243.     wrap->cycleCounterInit();
  244.     wrap->cycleCounterBeg();
  245.     wrap->cycleCounterPause();
  246. #endif
  247.  
  248.     addIntfListEntry(IASElist, intf, wrap);
  249.  
  250.     return  wrap;
  251. }
  252.  
  253. WSymWriter         *  __stdcall makeSYMWwrapper(void *intf)
  254. {
  255.     WSymWriter         *wrap;
  256.     WMetaData          *oldw;
  257.  
  258.     oldw = findIntfListEntry(SYMWlist, intf);
  259.     if  (oldw)
  260.         return  dynamic_cast<WSymWriter *>(oldw);
  261.  
  262.     wrap = new WSymWriter;
  263.  
  264.     wrap->useCount = 1;
  265.     wrap->isw      = intf;
  266.  
  267.     addIntfListEntry(SYMWlist, intf, wrap);
  268.  
  269.     return  wrap;
  270. }
  271.  
  272. /*****************************************************************************/
  273.  
  274. IMetaDataDispenser     *__stdcall  uwrpIMDDwrapper(WMetaDataDispenser *inst)
  275. {
  276.     return  inst->imdd;
  277. }
  278.  
  279. IMetaDataImport        *__stdcall  uwrpIMDIwrapper(WMetaDataImport    *inst)
  280. {
  281.     return  inst->imdi;
  282. }
  283.  
  284. IMetaDataEmit          *__stdcall  uwrpIMDEwrapper(WMetaDataEmit      *inst)
  285. {
  286.     return  inst->imde;
  287. }
  288.  
  289. IMetaDataAssemblyEmit  *__stdcall   uwrpIASEwrapper(WAssemblyEmit      *inst)
  290. {
  291.     return  inst->iase;
  292. }
  293.  
  294. IMetaDataAssemblyImport*__stdcall   uwrpIASIwrapper(WAssemblyImport    *inst)
  295. {
  296.     return  inst->iasi;
  297. }
  298.  
  299. /*****************************************************************************/
  300.  
  301. int WMetaDataDispenser::DefineScope(    const CLSID *       rclsid,
  302.                                         DWORD               dwCreateFlags,
  303.                                         const IID *         riid,
  304.                                         WMetaDataEmit   * * intfPtr)
  305. {
  306.     int             err;
  307.     IMetaDataEmit  *imde;
  308.  
  309.     err = imdd->DefineScope(*rclsid, dwCreateFlags, *riid, (IUnknown **)&imde);
  310.  
  311.     if  (err)
  312.     {
  313.         *intfPtr = NULL;
  314.     }
  315.     else
  316.     {
  317.         *intfPtr = makeIMDEwrapper(imde);
  318.     }
  319.  
  320.     return  err;
  321. }
  322.  
  323. int WMetaDataDispenser::DefineAssem(WMetaDataEmit     * emitPtr,
  324.                                     WAssemblyEmit   * * intfPtr)
  325. {
  326.     int                     err;
  327.     IMetaDataAssemblyEmit  *iase;
  328.  
  329.     err = emitPtr->imde->QueryInterface(IID_IMetaDataAssemblyEmit, (void **)&iase);
  330.  
  331.     if  (err)
  332.     {
  333.         *intfPtr = NULL;
  334.     }
  335.     else
  336.     {
  337.         *intfPtr = makeIASEwrapper(iase);
  338.     }
  339.  
  340.     return  err;
  341. }
  342.  
  343. int WMetaDataDispenser::OpenScope(      LPCWSTR             szScope,
  344.                                         DWORD               dwOpenFlags,
  345.                                         const IID *         riid,
  346.                                         WMetaDataImport * * intfPtr)
  347. {
  348.     int             err;
  349.     IMetaDataImport*imdi;
  350.  
  351. //  printf("this = %08X, scp = %08X, flags = %08X, ridd = %08X, intf = %08X\n", this, szScope, dwOpenFlags, riid, intfPtr);
  352.  
  353.     err = imdd->OpenScope(szScope, dwOpenFlags, *riid, (IUnknown **)&imdi);
  354.  
  355.     if  (err)
  356.     {
  357.         *intfPtr = NULL;
  358.     }
  359.     else
  360.     {
  361.         *intfPtr = makeIMDIwrapper(imdi);
  362.     }
  363.  
  364.     return  err;
  365. }
  366.  
  367. /*****************************************************************************/
  368. #if __BEGIN_ATROCIOUS_HACK__ || 1
  369. /*****************************************************************************/
  370.  
  371. static
  372. PIMAGE_SECTION_HEADER Cor_RtlImageRvaToSection(IN PIMAGE_NT_HEADERS NtHeaders,
  373.                                                IN PVOID Base,
  374.                                                IN ULONG Rva)
  375. {
  376.     ULONG i;
  377.     PIMAGE_SECTION_HEADER NtSection;
  378.  
  379.     NtSection = IMAGE_FIRST_SECTION( NtHeaders );
  380.     for (i=0; i<NtHeaders->FileHeader.NumberOfSections; i++) {
  381.         if (Rva >= NtSection->VirtualAddress &&
  382.             Rva < NtSection->VirtualAddress + NtSection->SizeOfRawData)
  383.             return NtSection;
  384.  
  385.         ++NtSection;
  386.     }
  387.  
  388.     return NULL;
  389. }
  390.  
  391.  
  392. static
  393. PVOID Cor_RtlImageRvaToVa(IN PIMAGE_NT_HEADERS NtHeaders,
  394.                           IN PVOID Base,
  395.                           IN ULONG Rva)
  396. {
  397.     PIMAGE_SECTION_HEADER NtSection = Cor_RtlImageRvaToSection(NtHeaders,
  398.                                                                Base,
  399.                                                                Rva);
  400.  
  401.     if (NtSection != NULL) {
  402.         return (PVOID)((PCHAR)Base +
  403.                        (Rva - NtSection->VirtualAddress) +
  404.                        NtSection->PointerToRawData);
  405.     }
  406.     else
  407.         return NULL;
  408. }
  409.  
  410. /* static */
  411. IMAGE_COR20_HEADER * getCOMHeader(HMODULE hMod, IMAGE_NT_HEADERS *pNT)
  412. {
  413.     PIMAGE_SECTION_HEADER pSectionHeader;
  414.  
  415.     // Get the image header from the image, then get the directory location
  416.     // of the COM+ header which may or may not be filled out.
  417.     pSectionHeader = (PIMAGE_SECTION_HEADER) Cor_RtlImageRvaToVa(pNT, hMod,
  418.                                                                  pNT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COMHEADER].VirtualAddress);
  419.  
  420.     return (IMAGE_COR20_HEADER *) pSectionHeader;
  421. }
  422.  
  423.  
  424. /* static */
  425. IMAGE_NT_HEADERS * FindNTHeader(PBYTE pbMapAddress)
  426. {
  427.     IMAGE_DOS_HEADER   *pDosHeader;
  428.     IMAGE_NT_HEADERS   *pNT;
  429.  
  430.     pDosHeader = (IMAGE_DOS_HEADER *) pbMapAddress;
  431.  
  432.     if ((pDosHeader->e_magic == IMAGE_DOS_SIGNATURE) &&
  433.         (pDosHeader->e_lfanew != 0))
  434.     {
  435.         pNT = (IMAGE_NT_HEADERS*) (pDosHeader->e_lfanew + (DWORD) pDosHeader);
  436.  
  437.         if ((pNT->Signature != IMAGE_NT_SIGNATURE) ||
  438.             (pNT->FileHeader.SizeOfOptionalHeader !=
  439.              IMAGE_SIZEOF_NT_OPTIONAL_HEADER) ||
  440.             (pNT->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC))
  441.             return NULL;
  442.     }
  443.     else
  444.         return NULL;
  445.  
  446.     return pNT;
  447. }
  448.  
  449. // @TODO: This opens a manifest created by LM -a.  Should be removed
  450. // once the -a option is removed from LM.
  451. // NOTE: The file mapping needs to be kept around as long as the returned
  452. // metadata scope is in use.  When finished, call UnmapViewOfFile(*pbMapAddress);
  453. int OpenLM_AAssem(IMetaDataDispenser *imdd,
  454.                   LPCSTR              szFileName,
  455.                   const IID *         riid,
  456.                   mdAssembly        * assTok,
  457.                   BYTE *            * fmapPtr,
  458.                   WAssemblyImport * * intfPtr)
  459. {
  460.     IMetaDataAssemblyImport *iasi;
  461.     IMAGE_COR20_HEADER      *pICH;
  462.     IMAGE_NT_HEADERS        *pNT;
  463.     DWORD                   *dwSize;
  464.  
  465.     BYTE    *               mapAddr = NULL;
  466.  
  467.     *fmapPtr = NULL;
  468.     *intfPtr = NULL;
  469.  
  470.     HANDLE hFile = CreateFileA(szFileName,
  471.                                GENERIC_READ,
  472.                                FILE_SHARE_READ,
  473.                                NULL,
  474.                                OPEN_EXISTING,
  475.                                FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
  476.                                NULL);
  477.  
  478.     if (hFile == INVALID_HANDLE_VALUE)
  479.         return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
  480.  
  481.     HANDLE hMapFile = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
  482.     DWORD dwFileLen = GetFileSize(hFile, 0);
  483.     CloseHandle(hFile);
  484.     if (!hMapFile)
  485.         return HRESULT_FROM_WIN32(GetLastError());
  486.  
  487.     mapAddr = (PBYTE) MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
  488.     CloseHandle(hMapFile);
  489.     if (!(mapAddr))
  490.         return HRESULT_FROM_WIN32(GetLastError());
  491.  
  492.     if ((!(pNT = FindNTHeader(mapAddr))) ||
  493.         (!(pICH = getCOMHeader((HMODULE) (mapAddr), pNT)))) {
  494.         UnmapViewOfFile(mapAddr);
  495.         return E_FAIL;
  496.     }
  497.  
  498.     int hr = E_FAIL;
  499.     if ((!pICH->Resources.Size) ||
  500.         (dwFileLen < pICH->Resources.VirtualAddress + pICH->Resources.Size) ||
  501.         (!(dwSize = (DWORD *) (mapAddr + pICH->Resources.VirtualAddress))) ||
  502.         (FAILED(hr = imdd->OpenScopeOnMemory(pICH->Resources.VirtualAddress + (mapAddr) + sizeof(DWORD),
  503.                                         *dwSize,
  504.                                         0,
  505.                                         *riid,
  506.                                         (IUnknown **)&iasi)))) {
  507.         UnmapViewOfFile(mapAddr);
  508.         return hr;
  509.     }
  510.  
  511.     if ((hr = iasi->GetAssemblyFromScope(assTok)) >= 0) {
  512.         *intfPtr = makeIASIwrapper(iasi);
  513.         *fmapPtr = mapAddr;
  514.         return S_OK;
  515.     }
  516.  
  517.     iasi->Release();
  518.     UnmapViewOfFile(mapAddr);
  519.     mapAddr = NULL;
  520.     return hr;
  521. }
  522.  
  523. void    WMetaDataDispenser::TossAssem(BYTE *cookie)
  524. {
  525.     if (cookie) UnmapViewOfFile(cookie);
  526. }
  527.  
  528. /*****************************************************************************/
  529. #endif
  530. /*****************************************************************************/
  531.  
  532. int WMetaDataDispenser::OpenAssem(      LPCWSTR             szScope,
  533.                                         DWORD               dwOpenFlags,
  534.                                         const IID *         riid,
  535.                                         LPCSTR              szFileName,
  536.                                         mdAssembly        * assTok,
  537.                                         BYTE *            * cookiePtr,
  538.                                         WAssemblyImport * * intfPtr)
  539. {
  540.     int                     err;
  541.     IMetaDataAssemblyImport*iasi;
  542.  
  543.     *cookiePtr = NULL;
  544.  
  545.     cycleCounterResume();
  546.     err = imdd->OpenScope(szScope, dwOpenFlags, *riid, (IUnknown **)&iasi);
  547.     cycleCounterPause();
  548.     logCall(err, "OpenScope");
  549.  
  550.     if  (err)
  551.     {
  552.         *intfPtr = NULL;
  553.     }
  554.     else
  555.     {
  556.         if  (iasi->GetAssemblyFromScope(assTok) >= 0)
  557.         {
  558.             *intfPtr = makeIASIwrapper(iasi);
  559.         }
  560.         else
  561.         {
  562.             iasi->Release();
  563.  
  564.             cycleCounterResume();
  565.             err = OpenLM_AAssem(imdd, szFileName, riid, assTok, cookiePtr, intfPtr);
  566.             cycleCounterPause();
  567.             logCall(err, "OpenLMassemHack");
  568.  
  569.             if  (err < 0)
  570.                 return  err;
  571.         }
  572.     }
  573.  
  574.     return  err;
  575. }
  576.  
  577. /*****************************************************************************/
  578.  
  579. void    WMetaDataImport::CloseEnum(HCORENUM hEnum)
  580. {
  581.     imdi->CloseEnum(hEnum);
  582. }
  583.  
  584. int     WMetaDataImport::CountEnum(HCORENUM hEnum, ULONG *pulCount)
  585. {
  586.     cycleCounterResume();
  587.     int     err = imdi->CountEnum(hEnum, pulCount);
  588.     cycleCounterPause();
  589.     logCall(err, "CountEnum");
  590.     return  err;
  591. }
  592.  
  593. int     WMetaDataImport::ResetEnum(HCORENUM hEnum, ULONG ulPos)
  594. {
  595.     cycleCounterResume();
  596.     int     err = imdi->ResetEnum(hEnum, ulPos);
  597.     cycleCounterPause();
  598.     logCall(err, "ResetEnum");
  599.     return  err;
  600. }
  601.  
  602. int     WMetaDataImport::EnumTypeDefs(HCORENUM *phEnum, mdTypeDef rTypeDefs[], ULONG cMax, ULONG *pcTypeDefs)
  603. {
  604.     cycleCounterResume();
  605.     int     err = imdi->EnumTypeDefs(phEnum, rTypeDefs, cMax, pcTypeDefs);
  606.     cycleCounterPause();
  607.     logCall(err, "EnumTypeDefs");
  608.     return  err;
  609. }
  610.  
  611. int     WMetaDataImport::EnumInterfaceImpls(HCORENUM *phEnum, mdTypeDef td, mdInterfaceImpl rImpls[], ULONG cMax, ULONG* pcImpls)
  612. {
  613.     cycleCounterResume();
  614.     int     err = imdi->EnumInterfaceImpls(phEnum, td, rImpls, cMax, pcImpls);
  615.     cycleCounterPause();
  616.     logCall(err, "EnumInterfaceImpls");
  617.     return  err;
  618. }
  619.  
  620. int     WMetaDataImport::EnumTypeRefs(HCORENUM *phEnum, mdTypeRef rTypeRefs[], ULONG cMax, ULONG* pcTypeRefs)
  621. {
  622.     cycleCounterResume();
  623.     int     err = imdi->EnumTypeRefs(phEnum, rTypeRefs, cMax, pcTypeRefs);
  624.     cycleCounterPause();
  625.     logCall(err, "EnumTypeRefs");
  626.     return  err;
  627. }
  628.  
  629. int     WMetaDataImport::GetTypeDefProps(
  630.             mdTypeDef       td,
  631.             LPWSTR          szTypeDef,
  632.             ULONG           cchTypeDef,
  633.             ULONG          *pchTypeDef,
  634.             CLASSVERSION   *pver,
  635.             DWORD          *pdwTypeDefFlags,
  636.             mdToken        *ptkExtends)
  637. {
  638.     cycleCounterResume();
  639.     int     err = imdi->GetTypeDefProps(td,
  640.                                   szTypeDef,
  641.                                   cchTypeDef,
  642.                                   pchTypeDef,
  643.                                   pver,
  644.                                   pdwTypeDefFlags,
  645.                                   ptkExtends);
  646.     cycleCounterPause();
  647.     logCall(err, "GetTypeDefProps");
  648.     return  err;
  649. }
  650.  
  651. int     WMetaDataImport::GetClassLayout(
  652.                 mdTypeDef   td,
  653.                 DWORD       *pdwPackSize,
  654.                 COR_FIELD_OFFSET rFieldOffset[],
  655.                 ULONG       cMax,
  656.                 ULONG       *pcFieldOffset,
  657.                 ULONG       *pulClassSize)
  658. {
  659.     cycleCounterResume();
  660.     int     err = imdi->GetClassLayout(td,
  661.                                        pdwPackSize,
  662.                                        rFieldOffset,
  663.                                        cMax,
  664.                                        pcFieldOffset,
  665.                                        pulClassSize);
  666.     cycleCounterPause();
  667.     logCall(err, "GetClassLayout");
  668.     return  err;
  669. }
  670.  
  671. int     WMetaDataImport::GetNestedClassProps(
  672.                 mdTypeDef       tdNestedClass,
  673.                 mdTypeDef      *ptdEnclosingClass)
  674. {
  675.     cycleCounterResume();
  676.     int     err = imdi->GetNestedClassProps(tdNestedClass, ptdEnclosingClass);
  677.     cycleCounterPause();
  678.     logCall(err, "GetNestedClassProps");
  679.     return  err;
  680. }
  681.  
  682. int     WMetaDataImport::GetFieldMarshal(
  683.             mdToken         tk,
  684.             PCCOR_SIGNATURE*ppvNativeType,
  685.             ULONG          *pcbNativeType)
  686. {
  687.     cycleCounterResume();
  688.     int     err = imdi->GetFieldMarshal(tk, ppvNativeType, pcbNativeType);
  689.     cycleCounterPause();
  690.     logCall(err, "GetFieldMarshal");
  691.     return  err;
  692. }
  693.  
  694. int     WMetaDataImport::GetPermissionSetProps(
  695.             mdPermission    pm,
  696.             DWORD          *pdwAction,
  697.             void const    **ppvPermission,
  698.             ULONG          *pcbPermission)
  699. {
  700.     cycleCounterResume();
  701.     int     err = imdi->GetPermissionSetProps(pm, pdwAction, ppvPermission, pcbPermission);
  702.     cycleCounterPause();
  703.     logCall(err, "GetPermissionSetProps");
  704.     return  err;
  705. }
  706.  
  707. int     WMetaDataImport::EnumMembers(
  708.             HCORENUM       *phEnum,
  709.             mdTypeDef       cl,
  710.             mdToken         rMembers[],
  711.             ULONG           cMax,
  712.             ULONG          *pcTokens)
  713. {
  714.     cycleCounterResume();
  715.     int     err = imdi->EnumMembers(phEnum,
  716.                               cl,
  717.                               rMembers,
  718.                               cMax,
  719.                               pcTokens);
  720.     cycleCounterPause();
  721.     logCall(err, "EnumMembers");
  722.     return  err;
  723. }
  724.  
  725. int     WMetaDataImport::GetMemberProps(
  726.             mdToken         mb,
  727.             mdTypeDef      *pClass,
  728.             LPWSTR          szMember,
  729.             ULONG           cchMember,
  730.             ULONG          *pchMember,
  731.             DWORD          *pdwAttr,
  732.             PCCOR_SIGNATURE*ppvSigBlob,
  733.             ULONG          *pcbSigBlob,
  734.             ULONG          *pulCodeRVA,
  735.             DWORD          *pdwImplFlags,
  736.             DWORD          *pdwCPlusTypeFlag,
  737.             void const    **ppValue,
  738.             ULONG          *pcbValue)
  739. {
  740.     cycleCounterResume();
  741.     int     err = imdi->GetMemberProps(mb,
  742.                                  pClass,
  743.                                  szMember,
  744.                                  cchMember,
  745.                                  pchMember,
  746.                                  pdwAttr,
  747.                                  ppvSigBlob,
  748.                                  pcbSigBlob,
  749.                                  pulCodeRVA,
  750.                                  pdwImplFlags,
  751.                                  pdwCPlusTypeFlag,
  752.                                  ppValue,
  753.                                  pcbValue);
  754.     cycleCounterPause();
  755.     logCall(err, "GetMemberProps");
  756.     return  err;
  757. }
  758.  
  759. int     WMetaDataImport::EnumProperties(
  760.             HCORENUM       *phEnum,
  761.             mdTypeDef       td,
  762.             mdProperty      rProperties[],
  763.             ULONG           cMax,
  764.             ULONG          *pcProperties)
  765. {
  766.     cycleCounterResume();
  767.     int     err = imdi->EnumProperties(phEnum, td, rProperties, cMax, pcProperties);
  768.     cycleCounterPause();
  769.     logCall(err, "EnumProperties");
  770.     return  err;
  771. }
  772.  
  773. int     WMetaDataImport::GetPropertyProps(
  774.             mdProperty      prop,
  775.             mdTypeDef      *pClass,
  776.             LPCWSTR         szProperty,
  777.             ULONG           cchProperty,
  778.             ULONG          *pchProperty,
  779.             DWORD          *pdwPropFlags,
  780.             PCCOR_SIGNATURE*ppvSig,
  781.             ULONG          *pbSig,
  782.             DWORD          *pdwCPlusTypeFlag,
  783.             void const    **ppDefaultValue,
  784.             ULONG          *pcbDefaultValue,
  785.             mdMethodDef    *pmdSetter,
  786.             mdMethodDef    *pmdGetter,
  787.             mdMethodDef     rmdOtherMethod[],
  788.             ULONG           cMax,
  789.             ULONG          *pcOtherMethod,
  790.             mdFieldDef     *pmdBackingField)
  791. {
  792.     cycleCounterResume();
  793.     int     err = imdi->GetPropertyProps(
  794.                             prop,
  795.                             pClass,
  796.                             szProperty,
  797.                             cchProperty,
  798.                             pchProperty,
  799.                             pdwPropFlags,
  800.                             ppvSig,
  801.                             pbSig,
  802.                             pdwCPlusTypeFlag,
  803.                             ppDefaultValue,
  804.                             pcbDefaultValue,
  805.                             pmdSetter,
  806.                             pmdGetter,
  807.                             rmdOtherMethod,
  808.                             cMax,
  809.                             pcOtherMethod,
  810.                             pmdBackingField);
  811.     cycleCounterPause();
  812.     logCall(err, "GetPropertyProps");
  813.     return  err;
  814. }
  815.  
  816. int     WMetaDataImport::EnumParams(
  817.             HCORENUM       *phEnum,
  818.             mdMethodDef     mb,
  819.             mdParamDef      rParams[],
  820.             ULONG           cMax,
  821.             ULONG          *pcTokens)
  822. {
  823.     cycleCounterResume();
  824.     int     err = imdi->EnumParams(phEnum,
  825.                              mb,
  826.                              rParams,
  827.                              cMax,
  828.                              pcTokens);
  829.     cycleCounterPause();
  830.     logCall(err, "EnumParams");
  831.     return  err;
  832. }
  833.  
  834. int     WMetaDataImport::GetParamProps(
  835.             mdToken         tk,
  836.             mdMethodDef    *pmd,
  837.             ULONG          *pulSequence,
  838.             LPWSTR          szName,
  839.             ULONG           cchName,
  840.             ULONG          *pchName,
  841.             DWORD          *pdwAttr,
  842.             DWORD          *pdwCPlusTypeFlag,
  843.             void const    **ppValue,
  844.             ULONG          *pcbValue)
  845. {
  846.     cycleCounterResume();
  847.     int     err = imdi->GetParamProps(tk,
  848.                                 pmd,
  849.                                 pulSequence,
  850.                                 szName,
  851.                                 cchName,
  852.                                 pchName,
  853.                                 pdwAttr,
  854.                                 pdwCPlusTypeFlag,
  855.                                 ppValue,
  856.                                 pcbValue);
  857.     cycleCounterPause();
  858.     logCall(err, "GetParamProps");
  859.     return  err;
  860. }
  861.  
  862. int     WMetaDataImport::GetScopeProps(
  863.             LPWSTR          szName,
  864.             ULONG           cchName,
  865.             ULONG          *pchName,
  866.             GUID           *pmvid)
  867. {
  868.     cycleCounterResume();
  869.     int     err = imdi->GetScopeProps(szName, cchName, pchName, pmvid);
  870.     cycleCounterPause();
  871.     logCall(err, "GetScopeProps");
  872.     return  err;
  873. }
  874.  
  875. int     WMetaDataImport::GetNameFromToken(mdToken tk, const char **pszUtf8NamePtr)
  876. {
  877.     cycleCounterResume();
  878.     int     err = imdi->GetNameFromToken(tk, pszUtf8NamePtr);
  879.     cycleCounterPause();
  880.     logCall(err, "GetNameFromToken");
  881.     return  err;
  882. }
  883.  
  884. int     WMetaDataImport::GetInterfaceImplProps(
  885.             mdInterfaceImpl iiImpl,
  886.             mdTypeDef      *pClass,
  887.             mdToken        *ptkIface)
  888. {
  889.     cycleCounterResume();
  890.     int     err = imdi->GetInterfaceImplProps(iiImpl, pClass, ptkIface);
  891.     cycleCounterPause();
  892.     logCall(err, "GetInterfaceImplProps");
  893.     return  err;
  894. }
  895.  
  896. int     WMetaDataImport::GetTypeRefProps(
  897.             mdTypeRef   tr,
  898.             mdToken     tkResolutionScope,
  899.             LPWSTR      szTypeRef,
  900.             ULONG       cchTypeRef,
  901.             ULONG      *pchTypeRef)
  902. {
  903.     cycleCounterResume();
  904.     int     err = imdi->GetTypeRefProps(tr,
  905.                                 &tkResolutionScope,
  906.                                 szTypeRef,
  907.                                 cchTypeRef,
  908.                                 pchTypeRef);
  909.     cycleCounterPause();
  910.     logCall(err, "GetTypeRefProps");
  911.     return  err;
  912. }
  913.  
  914. int     WMetaDataImport::GetMemberRefProps(
  915.             mdMemberRef     mr,
  916.             mdToken        *ptk,
  917.             LPWSTR          szMember,
  918.             ULONG           cchMember,
  919.             ULONG          *pchMember,
  920.             PCCOR_SIGNATURE*ppvSigBlob,
  921.             ULONG          *pbSig)
  922. {
  923.     cycleCounterResume();
  924.     int     err = imdi->GetMemberRefProps(mr, ptk, szMember, cchMember, pchMember, ppvSigBlob, pbSig);
  925.     cycleCounterPause();
  926.     logCall(err, "GetMemberRefProps");
  927.     return  err;
  928. }
  929.  
  930. int     WMetaDataImport::GetMethodProps(
  931.             mdMethodDef     mb,
  932.             mdTypeDef      *pClass,
  933.             LPWSTR          szMethod,
  934.             ULONG           cchMethod,
  935.             ULONG          *pchMethod,
  936.             DWORD          *pdwAttr,
  937.             PCCOR_SIGNATURE*ppvSigBlob,
  938.             ULONG          *pcbSigBlob,
  939.             ULONG          *pulCodeRVA,
  940.             DWORD          *pdwImplFlags)
  941. {
  942.     cycleCounterResume();
  943.     int     err = imdi->GetMethodProps(mb, pClass, szMethod, cchMethod, pchMethod, pdwAttr, ppvSigBlob, pcbSigBlob, pulCodeRVA, pdwImplFlags);
  944.     cycleCounterPause();
  945.     logCall(err, "GetMethodProps");
  946.     return  err;
  947. }
  948.  
  949. int     WMetaDataImport::ResolveTypeRef(mdTypeRef tr, const IID * riid, WMetaDataImport **scope, mdTypeDef *ptd)
  950. {
  951.     int             err;
  952.     IMetaDataImport*imdiNew;
  953.  
  954.     cycleCounterResume();
  955.     err = imdi->ResolveTypeRef(tr, *riid, (IUnknown **)&imdiNew, ptd);
  956.     cycleCounterPause();
  957.     if  (err)
  958.     {
  959.         *scope = NULL;
  960.     }
  961.     else
  962.     {
  963.         *scope = makeIMDIwrapper(imdiNew);
  964.     }
  965.  
  966.     logCall(err, "ResolveTypeRef");
  967.     return  err;
  968. }
  969.  
  970. int     WMetaDataImport::FindTypeRef(
  971.             mdToken         tkResolutionScope,
  972.             LPCWSTR         szTypeName,
  973.             mdTypeRef      *ptr)
  974. {
  975.     cycleCounterResume();
  976.     int     err = imdi->FindTypeRef(tkResolutionScope,
  977.                                 szTypeName,
  978.                                 ptr);
  979.     cycleCounterPause();
  980.     logCall(err, "FindTypeRef");
  981.     return  err;
  982. }
  983.  
  984. int     WMetaDataImport::GetCustomAttributeByName(mdToken tkObj, LPCWSTR szName, void const **ppBlob, ULONG *pcbSize)
  985. {
  986.     cycleCounterResume();
  987.     int     err = imdi->GetCustomAttributeByName(tkObj, szName, ppBlob,pcbSize);
  988.     cycleCounterPause();
  989.     logCall(err, "GetCustomAttributeByName");
  990.     return  err;
  991. }
  992.  
  993. int     WMetaDataImport::EnumCustomAttributes(
  994.                 HCORENUM       *phEnum,
  995.                 mdToken         tk,
  996.                 mdToken         tkType,
  997.                 mdCustomValue   rCustomValues[],
  998.                 ULONG           cMax,
  999.                 ULONG          *pcCustomValues)
  1000. {
  1001.     cycleCounterResume();
  1002.     int     err = imdi->EnumCustomAttributes(phEnum, tk, tkType, rCustomValues, cMax, pcCustomValues);
  1003.     cycleCounterPause();
  1004.     logCall(err, "EnumCustomAttributes");
  1005.     return  err;
  1006. }
  1007.  
  1008. int     WMetaDataImport::GetCustomAttributeProps(
  1009.                 mdCustomValue   cv,
  1010.                 mdToken        *ptkObj,
  1011.                 mdToken        *ptkType,
  1012.                 void const    **ppBlob,
  1013.                 ULONG          *pcbSize)
  1014. {
  1015.     cycleCounterResume();
  1016.     int     err = imdi->GetCustomAttributeProps(cv, ptkObj, ptkType, ppBlob, pcbSize);
  1017.     cycleCounterPause();
  1018.     logCall(err, "GetCustomAttributeProps");
  1019.     return  err;
  1020. }
  1021.  
  1022. /*****************************************************************************/
  1023.  
  1024. int     WMetaDataEmit::GetSaveSize(CorSaveSize fSave, DWORD *pdwSaveSize)
  1025. {
  1026.     cycleCounterResume();
  1027.     int     err = imde->GetSaveSize(fSave, pdwSaveSize);
  1028.     cycleCounterPause();
  1029.     logCall(err, "GetSaveSize");
  1030.     return  err;
  1031. }
  1032.  
  1033. int     WMetaDataEmit::DefineTypeDef(
  1034.             LPCWSTR         szTypeDef,
  1035.             CLASSVERSION   *pVer,
  1036.             DWORD           dwTypeDefFlags,
  1037.             mdToken         tkExtends,
  1038.             mdToken         rtkImplements[],
  1039.             mdTypeDef      *ptd)
  1040. {
  1041.     cycleCounterResume();
  1042.     int     err = imde->DefineTypeDef(szTypeDef,
  1043.                                 pVer,
  1044.                                 dwTypeDefFlags,
  1045.                                 tkExtends,
  1046.                                 rtkImplements,
  1047.                                 ptd);
  1048.     cycleCounterPause();
  1049.     logCall(err, "DefineTypeDef");
  1050.     return  err;
  1051. }
  1052.  
  1053. int     WMetaDataEmit::DefineNestedType(
  1054.             LPCWSTR         szTypeDef,
  1055.             CLASSVERSION   *pVer,
  1056.             DWORD           dwTypeDefFlags,
  1057.             mdToken         tkExtends,
  1058.             mdToken         rtkImplements[],
  1059.             mdTypeDef       tkEncloser,
  1060.             mdTypeDef      *ptd)
  1061. {
  1062.     cycleCounterResume();
  1063.     int     err = imde->DefineNestedType(szTypeDef,
  1064.                                 pVer,
  1065.                                 dwTypeDefFlags,
  1066.                                 tkExtends,
  1067.                                 rtkImplements,
  1068.                                 tkEncloser,
  1069.                                 ptd);
  1070.     cycleCounterPause();
  1071.     logCall(err, "DefineNestedType");
  1072.     return  err;
  1073. }
  1074.  
  1075. int     WMetaDataEmit::SetTypeDefProps(
  1076.             mdTypeDef       td,
  1077.             CLASSVERSION   *pVer,
  1078.             DWORD           dwTypeDefFlags,
  1079.             mdToken         tkExtends,
  1080.             mdToken         rtkImplements[])
  1081. {
  1082.     cycleCounterResume();
  1083.     int     err = imde->SetTypeDefProps(td,
  1084.                                   pVer,
  1085.                                   dwTypeDefFlags,
  1086.                                   tkExtends,
  1087.                                   rtkImplements);
  1088.     cycleCounterPause();
  1089.     logCall(err, "SetTypeDefProps");
  1090.     return  err;
  1091. }
  1092.  
  1093. int     WMetaDataEmit::DefineMethod(
  1094.             mdTypeDef       td,
  1095.             LPCWSTR         szName,
  1096.             DWORD           dwMethodFlags,
  1097.             PCCOR_SIGNATURE pvSigBlob,
  1098.             ULONG           cbSigBlob,
  1099.             ULONG           ulCodeRVA,
  1100.             DWORD           dwImplFlags,
  1101.             mdMethodDef    *pmd)
  1102. {
  1103.     cycleCounterResume();
  1104.     int     err = imde->DefineMethod(td,
  1105.                                szName,
  1106.                                dwMethodFlags,
  1107.                                pvSigBlob,
  1108.                                cbSigBlob,
  1109.                                ulCodeRVA,
  1110.                                dwImplFlags,
  1111.                                pmd);
  1112.     cycleCounterPause();
  1113.     logCall(err, "DefineMethod");
  1114.     return  err;
  1115. }
  1116.  
  1117. int     WMetaDataEmit::DefineField(
  1118.             mdTypeDef       td,
  1119.             LPCWSTR         szName,
  1120.             DWORD           dwFieldFlags,
  1121.             PCCOR_SIGNATURE pvSigBlob,
  1122.             ULONG           cbSigBlob,
  1123.             DWORD           dwCPlusTypeFlag,
  1124.             void const     *pValue,
  1125.             ULONG           cbValue,
  1126.             mdFieldDef     *pmd)
  1127. {
  1128.     cycleCounterResume();
  1129.     int     err = imde->DefineField(td,
  1130.                               szName,
  1131.                               dwFieldFlags,
  1132.                               pvSigBlob,
  1133.                               cbSigBlob,
  1134.                               dwCPlusTypeFlag,
  1135.                               pValue,
  1136.                               cbValue,
  1137.                               pmd);
  1138.     cycleCounterPause();
  1139.     logCall(err, "DefineField");
  1140.     return  err;
  1141. }
  1142.  
  1143. int     WMetaDataEmit::DefineProperty(
  1144.             mdTypeDef       td,
  1145.             LPCWSTR         szProperty,
  1146.             DWORD           dwPropFlags,
  1147.             PCCOR_SIGNATURE pvSig,
  1148.             ULONG           cbSig,
  1149.             DWORD           dwCPlusTypeFlag,
  1150.             void const     *pValue,
  1151.             ULONG           cbValue,
  1152.             mdMethodDef     mdSetter,
  1153.             mdMethodDef     mdGetter,
  1154.             mdMethodDef     rmdOtherMethods[],
  1155.             mdFieldDef      fdBackingField,
  1156.             mdProperty     *pmdProp)
  1157. {
  1158.     cycleCounterResume();
  1159.     int     err = imde->DefineProperty(td,
  1160.                                        szProperty,
  1161.                                        dwPropFlags,
  1162.                                        pvSig,
  1163.                                        cbSig,
  1164.                                        dwCPlusTypeFlag,
  1165.                                        pValue,
  1166.                                        cbValue,
  1167.                                        mdSetter,
  1168.                                        mdGetter,
  1169.                                        rmdOtherMethods,
  1170.                                        fdBackingField,
  1171.                                        pmdProp);
  1172.     cycleCounterPause();
  1173.     logCall(err, "DefineProperty");
  1174.     return  err;
  1175. }
  1176.  
  1177. int     WMetaDataEmit::DefineParam(
  1178.             mdMethodDef     md,
  1179.             ULONG           ulParamSeq,
  1180.             LPCWSTR         szName,
  1181.             DWORD           dwParamFlags,
  1182.             DWORD           dwCPlusTypeFlag,
  1183.             void const     *pValue,
  1184.             ULONG           cbValue,
  1185.             mdParamDef     *ppd)
  1186. {
  1187.     cycleCounterResume();
  1188.     int     err = imde->DefineParam(md,
  1189.                                     ulParamSeq,
  1190.                                     szName,
  1191.                                     dwParamFlags,
  1192.                                     dwCPlusTypeFlag,
  1193.                                     pValue,
  1194.                                     cbValue,
  1195.                                     ppd);
  1196.     cycleCounterPause();
  1197.     logCall(err, "DefineParam");
  1198.     return  err;
  1199. }
  1200.  
  1201. int     WMetaDataEmit::DefineMethodImpl(
  1202.             mdTypeDef       td,
  1203.             mdToken         tkBody,
  1204.             mdToken         tkDecl)
  1205. {
  1206.     cycleCounterResume();
  1207.     int     err = imde->DefineMethodImpl(td,
  1208.                                    tkBody,
  1209.                                    tkDecl);
  1210.     cycleCounterPause();
  1211.     logCall(err, "DefineMethodImpl");
  1212.     return  err;
  1213. }
  1214.  
  1215. int     WMetaDataEmit::SetRVA(
  1216.             mdToken         md,
  1217.             ULONG           ulCodeRVA)
  1218. {
  1219.     cycleCounterResume();
  1220.     int     err = imde->SetRVA(md,
  1221.                          ulCodeRVA);
  1222.     cycleCounterPause();
  1223.     logCall(err, "SetRVA");
  1224.     return  err;
  1225. }
  1226.  
  1227. int     WMetaDataEmit::SetMethodImplFlags(
  1228.             mdToken         md,
  1229.             DWORD           dwImplFlags)
  1230. {
  1231.     cycleCounterResume();
  1232.     int     err = imde->SetMethodImplFlags(md,
  1233.                          dwImplFlags);
  1234.     cycleCounterPause();
  1235.     logCall(err, "SetMethodImplFlags");
  1236.     return  err;
  1237. }
  1238.  
  1239. int     WMetaDataEmit::DefineTypeRefByName(
  1240.             mdToken         tkResolutionScope,
  1241.             LPCWSTR         szName,
  1242.             mdTypeRef      *ptr)
  1243. {
  1244.     cycleCounterResume();
  1245.     int     err = imde->DefineTypeRefByName(tkResolutionScope, szName, ptr);
  1246.     cycleCounterPause();
  1247.     logCall(err, "DefineTypeRefByName");
  1248.     return  err;
  1249. }
  1250.  
  1251. int     WMetaDataEmit::DefineImportType(
  1252.             IMetaDataAssemblyImport *pAssemImport,
  1253.             const void      *pbHashValue,
  1254.             ULONG           cbHashValue,
  1255.             mdExecutionLocation tkExec,
  1256.             IMetaDataImport *pImport,
  1257.             mdTypeDef       tdImport,
  1258.             IMetaDataAssemblyEmit *pAssemEmit,
  1259.             mdTypeRef      *ptr)
  1260. {
  1261.     cycleCounterResume();
  1262.     int     err = imde->DefineImportType(pAssemImport,
  1263.                                    pbHashValue,
  1264.                                    cbHashValue,
  1265.                                    tkExec,
  1266.                                    pImport,
  1267.                                    tdImport,
  1268.                                    pAssemEmit,
  1269.                                    ptr);
  1270.     cycleCounterPause();
  1271.     logCall(err, "DefineImportType");
  1272.     return  err;
  1273. }
  1274.  
  1275. int     WMetaDataEmit::DefineMemberRef(
  1276.             mdToken         tkImport,
  1277.             LPCWSTR         szName,
  1278.             PCCOR_SIGNATURE pvSigBlob,
  1279.             ULONG           cbSigBlob,
  1280.             mdMemberRef    *pmr)
  1281. {
  1282.     cycleCounterResume();
  1283.     int     err = imde->DefineMemberRef(tkImport,
  1284.                                   szName,
  1285.                                   pvSigBlob,
  1286.                                   cbSigBlob,
  1287.                                   pmr);
  1288.     cycleCounterPause();
  1289.     logCall(err, "DefineMemberRef");
  1290.     return  err;
  1291. }
  1292.  
  1293. int     WMetaDataEmit::DefineImportMember(
  1294.             IMetaDataAssemblyImport *pAssemImport,
  1295.             const void      *pbHashValue,
  1296.             ULONG           cbHashValue,
  1297.             mdExecutionLocation tkExec,
  1298.             IMetaDataImport *pImport,
  1299.             mdToken         mbMember,
  1300.             IMetaDataAssemblyEmit *pAssemEmit,
  1301.             mdToken         tkParent,
  1302.             mdMemberRef    *pmr)
  1303. {
  1304.     cycleCounterResume();
  1305.     int     err = imde->DefineImportMember(pAssemImport,
  1306.                                      pbHashValue,
  1307.                                      cbHashValue,
  1308.                                      tkExec,
  1309.                                      pImport,
  1310.                                      mbMember,
  1311.                                      pAssemEmit,
  1312.                                      tkParent,
  1313.                                      pmr);
  1314.     cycleCounterPause();
  1315.     logCall(err, "DefineImportMember");
  1316.     return  err;
  1317. }
  1318.  
  1319. int     WMetaDataEmit::DefineModuleRef(LPCWSTR szName, mdModuleRef *pmur)
  1320. {
  1321.     cycleCounterResume();
  1322.     int     err = imde->DefineModuleRef(szName, pmur);
  1323.     cycleCounterPause();
  1324.     logCall(err, "DefineModuleRef");
  1325.     return  err;
  1326. }
  1327.  
  1328. int     WMetaDataEmit::DefineUserString(
  1329.                 LPCWSTR         szString,
  1330.                 ULONG           cchString,
  1331.                 mdString       *pstk)
  1332. {
  1333.     int     err = imde->DefineUserString(szString, cchString, pstk);
  1334.     logCall(err, "DefineUserString");
  1335.     return  err;
  1336. }
  1337.  
  1338. int     WMetaDataEmit::DefinePinvokeMap(
  1339.                 mdToken         tk,
  1340.                 DWORD           dwMappingFlags,
  1341.                 LPCWSTR         szImportName,
  1342.                 mdModuleRef     mrImportDLL)
  1343. {
  1344.     cycleCounterResume();
  1345.     int     err = imde->DefinePinvokeMap(tk,
  1346.                                          dwMappingFlags,
  1347.                                          szImportName,
  1348.                                          mrImportDLL);
  1349.     cycleCounterPause();
  1350.     logCall(err, "DefinePinvokeMap");
  1351.     return  err;
  1352. }
  1353.  
  1354. int     WMetaDataEmit::SetClassLayout(
  1355.             mdTypeDef        td,
  1356.             DWORD            dwPackSize,
  1357.             COR_FIELD_OFFSET rFieldOffsets[],
  1358.             ULONG            ulClassSize)
  1359. {
  1360.     cycleCounterResume();
  1361.     int     err = imde->SetClassLayout(td,
  1362.                                  dwPackSize,
  1363.                                  rFieldOffsets,
  1364.                                  ulClassSize);
  1365.     cycleCounterPause();
  1366.     logCall(err, "SetClassLayout");
  1367.     return  err;
  1368. }
  1369.  
  1370. int     WMetaDataEmit::SetFieldMarshal(
  1371.             mdToken         tk,
  1372.             PCCOR_SIGNATURE pvNativeType,
  1373.             ULONG           cbNativeType)
  1374. {
  1375.     cycleCounterResume();
  1376.     int     err = imde->SetFieldMarshal(tk, pvNativeType, cbNativeType);
  1377.     cycleCounterPause();
  1378.     logCall(err, "SetFieldMarshal");
  1379.     return  err;
  1380. }
  1381.  
  1382. int     WMetaDataEmit::SetFieldRVA(mdFieldDef fd, ULONG ulRVA)
  1383. {
  1384.     cycleCounterResume();
  1385.     int     err = imde->SetFieldRVA(fd, ulRVA);
  1386.     cycleCounterPause();
  1387.     logCall(err, "SetFieldRVA");
  1388.     return  err;
  1389. }
  1390.  
  1391. int     WMetaDataEmit::DefinePermissionSet(
  1392.             mdToken         tk,
  1393.             DWORD           dwAction,
  1394.             void const     *pvPermission,
  1395.             ULONG           cbPermission,
  1396.             mdPermission   *ppm)
  1397. {
  1398.     cycleCounterResume();
  1399.     int     err = imde->DefinePermissionSet(tk, dwAction, pvPermission, cbPermission, ppm);
  1400.     cycleCounterPause();
  1401.     logCall(err, "DefinePermissionSet");
  1402.     return  err;
  1403. }
  1404.  
  1405. int     WMetaDataEmit::GetTokenFromSig(
  1406.             PCCOR_SIGNATURE pvSig,
  1407.             ULONG           cbSig,
  1408.             mdSignature    *pmsig)
  1409. {
  1410.     cycleCounterResume();
  1411.     int     err = imde->GetTokenFromSig(pvSig, cbSig, pmsig);
  1412.     cycleCounterPause();
  1413.     logCall(err, "GetTokenFromSig");
  1414.     return  err;
  1415. }
  1416.  
  1417. int     WMetaDataEmit::SetParent(
  1418.             mdMemberRef     mr,
  1419.             mdToken         tk)
  1420. {
  1421.     cycleCounterResume();
  1422.     int     err = imde->SetParent(mr, tk);
  1423.     cycleCounterPause();
  1424.     logCall(err, "SetParent");
  1425.     return  err;
  1426. }
  1427.  
  1428. int     WMetaDataEmit::SaveToMemory(
  1429.             void           *pbData,
  1430.             ULONG           cbData)
  1431. {
  1432.     cycleCounterResume();
  1433.     int     err = imde->SaveToMemory(pbData, cbData);
  1434.     cycleCounterPause();
  1435.     logCall(err, "SaveToMemory");
  1436.     return  err;
  1437. }
  1438.  
  1439. int     WMetaDataEmit::DefineCustomAttribute(
  1440.                 mdToken         tkObj,
  1441.                 mdToken         tkType,
  1442.                 void const     *pCustomValue,
  1443.                 ULONG           cbCustomValue,
  1444.                 mdCustomValue  *pcv)
  1445. {
  1446.     cycleCounterResume();
  1447.     int     err = imde->DefineCustomAttribute(tkObj,
  1448.                                               tkType,
  1449.                                               pCustomValue,
  1450.                                               cbCustomValue,
  1451.                                               pcv);
  1452.     cycleCounterPause();
  1453.     logCall(err, "DefineCustomAttribute");
  1454.     return  err;
  1455. }
  1456.  
  1457. int     WMetaDataEmit::GetTokenFromTypeSpec(
  1458.                 PCCOR_SIGNATURE pvSig,
  1459.                 ULONG           cbSig,
  1460.                 mdTypeSpec     *ptypespec)
  1461. {
  1462.     cycleCounterResume();
  1463.     int     err = imde->GetTokenFromTypeSpec(pvSig, cbSig, ptypespec);
  1464.     cycleCounterPause();
  1465.     logCall(err, "GetTokenFromTypeSpec");
  1466.     return  err;
  1467. }
  1468.  
  1469. int     WMetaDataEmit::SetModuleProps(
  1470.                 LPCWSTR         szName)
  1471. {
  1472.     cycleCounterResume();
  1473.     int     err = imde->SetModuleProps(szName);
  1474.     cycleCounterPause();
  1475.     logCall(err, "SetModuleProps");
  1476.     return  err;
  1477. }
  1478.  
  1479. /*****************************************************************************/
  1480.  
  1481. int     WAssemblyImport::GetAssemblyFromScope(mdAssembly *ptkAssembly)
  1482. {
  1483.     cycleCounterResume();
  1484.     int     err = iasi->GetAssemblyFromScope(ptkAssembly);
  1485.     cycleCounterPause();
  1486.     logCall(err, "GetAssemblyFromScope");
  1487.     return  err;
  1488. };
  1489.  
  1490. int     WAssemblyImport::GetAssemblyProps(
  1491.                 mdAssembly      mda,
  1492.                 const void    **ppbOriginator,
  1493.                 ULONG          *pcbOriginator,
  1494.                 ULONG          *pulHashAlgId,
  1495.                 LPWSTR          szName,
  1496.                 ULONG           cchName,
  1497.                 ULONG          *pchName,
  1498.                 ASSEMBLYMETADATA *pMetaData,
  1499.                 LPWSTR          szTitle,
  1500.                 ULONG           cchTitle,
  1501.                 ULONG          *pchTitle,
  1502.                 LPWSTR          szDescription,
  1503.                 ULONG           cchDescription,
  1504.                 ULONG          *pchDescription,
  1505.                 LPWSTR          szDefaultAlias,
  1506.                 ULONG           cchDefaultAlias,
  1507.                 ULONG          *pchDefaultAlias,
  1508.                 DWORD          *pdwAssemblyFlags)
  1509. {
  1510.     cycleCounterResume();
  1511.     int     err = iasi->GetAssemblyProps(
  1512.                 mda,
  1513.                 ppbOriginator,
  1514.                 pcbOriginator,
  1515.                 pulHashAlgId,
  1516.                 szName,
  1517.                 cchName,
  1518.                 pchName,
  1519.                 pMetaData,
  1520.                 szTitle,
  1521.                 cchTitle,
  1522.                 pchTitle,
  1523.                 szDescription,
  1524.                 cchDescription,
  1525.                 pchDescription,
  1526.                 szDefaultAlias,
  1527.                 cchDefaultAlias,
  1528.                 pchDefaultAlias,
  1529.                 pdwAssemblyFlags);
  1530.     cycleCounterPause();
  1531.     logCall(err, "GetAssemblyProps");
  1532.     return  err;
  1533. }
  1534.  
  1535. int     WAssemblyImport::EnumComTypes(
  1536.                 HCORENUM       *phEnum,
  1537.                 mdComType       rComTypes[],
  1538.                 ULONG           cMax,
  1539.                 ULONG          *pcTokens)
  1540. {
  1541.     cycleCounterResume();
  1542.     int     err = iasi->EnumComTypes(phEnum, rComTypes, cMax, pcTokens);
  1543.     cycleCounterPause();
  1544.     logCall(err, "EnumComTypes");
  1545.     return  err;
  1546. }
  1547.  
  1548. int     WAssemblyImport::GetComTypeProps(
  1549.                 mdComType       mdct,
  1550.                 LPWSTR          szName,
  1551.                 ULONG           cchName,
  1552.                 ULONG          *pchName,
  1553.                 LPWSTR          szDescription,
  1554.                 ULONG           cchDescription,
  1555.                 ULONG          *pchDescription,
  1556.                 mdToken        *ptkImplementation,
  1557.                 mdTypeDef      *ptkTypeDef,
  1558.                 mdExecutionLocation *ptkExecutionLocation,
  1559.                 DWORD          *pdwComTypeFlags)
  1560. {
  1561.     cycleCounterResume();
  1562.     int     err = iasi->GetComTypeProps(
  1563.                 mdct,
  1564.                 szName,
  1565.                 cchName,
  1566.                 pchName,
  1567.                 szDescription,
  1568.                 cchDescription,
  1569.                 pchDescription,
  1570.                 ptkImplementation,
  1571.                 ptkTypeDef,
  1572.                 ptkExecutionLocation,
  1573.                 pdwComTypeFlags);
  1574.     cycleCounterPause();
  1575.     logCall(err, "GetComTypeProps");
  1576.     return  err;
  1577. }
  1578.  
  1579. int     WAssemblyImport::EnumFiles(
  1580.                 HCORENUM       *phEnum,
  1581.                 mdFile          rFiles[],
  1582.                 ULONG           cMax,
  1583.                 ULONG          *pcTokens)
  1584. {
  1585.     cycleCounterResume();
  1586.     int     err = iasi->EnumFiles(phEnum, rFiles, cMax, pcTokens);
  1587.     cycleCounterPause();
  1588.     logCall(err, "EnumFiles");
  1589.     return  err;
  1590. }
  1591.  
  1592. int     WAssemblyImport::GetFileProps(
  1593.                 mdFile          mdf,
  1594.                 LPWSTR          szName,
  1595.                 ULONG           cchName,
  1596.                 ULONG          *pchName,
  1597.                 const void    **ppbHashValue,
  1598.                 ULONG          *pcbHashValue,
  1599.                 DWORD          *pdwFileFlags)
  1600. {
  1601.     cycleCounterResume();
  1602.     int     err = iasi->GetFileProps(
  1603.                 mdf,
  1604.                 szName,
  1605.                 cchName,
  1606.                 pchName,
  1607.                 ppbHashValue,
  1608.                 pcbHashValue,
  1609.                 pdwFileFlags);
  1610.     cycleCounterPause();
  1611.     logCall(err, "GetFileProps");
  1612.     return  err;
  1613. }
  1614.  
  1615. void    WAssemblyImport::CloseEnum(HCORENUM hEnum)
  1616. {
  1617.     cycleCounterResume();
  1618.     iasi->CloseEnum(hEnum);
  1619.     cycleCounterPause();
  1620.     logCall(0, "CloseEnum");
  1621. }
  1622.  
  1623. /*****************************************************************************/
  1624.  
  1625. int     WAssemblyEmit::DefineAssembly(
  1626.                 const void  *pbOriginator,
  1627.                 ULONG       cbOriginator,
  1628.                 ULONG       ulHashAlgId,
  1629.                 LPCWSTR     szName,
  1630.                 const ASSEMBLYMETADATA *pMetaData,
  1631.                 LPCWSTR     szTitle,
  1632.                 LPCWSTR     szDescription,
  1633.                 LPCWSTR     szDefaultAlias,
  1634.                 DWORD       dwAssemblyFlags,
  1635.                 mdAssembly  *pma)
  1636. {
  1637.     cycleCounterResume();
  1638.     int     err = iase->DefineAssembly(
  1639.                 pbOriginator,
  1640.                 cbOriginator,
  1641.                 ulHashAlgId,
  1642.                 szName,
  1643.                 pMetaData,
  1644.                 szTitle,
  1645.                 szDescription,
  1646.                 szDefaultAlias,
  1647.                 dwAssemblyFlags,
  1648.                 pma);
  1649.     cycleCounterPause();
  1650.     logCall(err, "DefineAssembly");
  1651.     return  err;
  1652. }
  1653.  
  1654. int     WAssemblyEmit::DefineFile(
  1655.                 LPCWSTR     szName,
  1656.                 const void  *pbHashValue,
  1657.                 ULONG       cbHashValue,
  1658.                 DWORD       dwFileFlags,
  1659.                 mdFile      *pmdf)
  1660. {
  1661.     cycleCounterResume();
  1662.     int     err = iase->DefineFile(
  1663.                 szName,
  1664.                 pbHashValue,
  1665.                 cbHashValue,
  1666.                 dwFileFlags,
  1667.                 pmdf);
  1668.     cycleCounterPause();
  1669.     logCall(err, "DefineFile");
  1670.     return  err;
  1671. }
  1672.  
  1673. int     WAssemblyEmit::DefineComType(
  1674.                 LPCWSTR     szName,
  1675.                 LPCWSTR     szDescription,
  1676.                 mdToken     tkImplementation,
  1677.                 mdTypeDef   tkTypeDef,
  1678.                 mdExecutionLocation tkExecutionLocation,
  1679.                 DWORD       dwComTypeFlags,
  1680.                 mdComType   *pmdct)
  1681. {
  1682.     cycleCounterResume();
  1683.     int     err = iase->DefineComType(
  1684.                 szName,
  1685.                 szDescription,
  1686.                 tkImplementation,
  1687.                 tkTypeDef,
  1688.                 tkExecutionLocation,
  1689.                 dwComTypeFlags,
  1690.                 pmdct);
  1691.     cycleCounterPause();
  1692.     logCall(err, "DefineComType");
  1693.     return  err;
  1694. }
  1695.  
  1696. int     WAssemblyEmit::DefineAssemblyRef(
  1697.                 const void  *pbOriginator,
  1698.                 ULONG       cbOriginator,
  1699.                 LPCWSTR     szName,
  1700.                 const ASSEMBLYMETADATA *pMetaData,
  1701.                 const void  *pbHashValue,
  1702.                 ULONG       cbHashValue,
  1703.                 mdExecutionLocation tkExecutionLocation,
  1704.                 DWORD       dwAssemblyRefFlags,
  1705.                 mdAssemblyRef *pmdar)
  1706. {
  1707.     cycleCounterResume();
  1708.     int     err = iase->DefineAssemblyRef(
  1709.                 pbOriginator,
  1710.                 cbOriginator,
  1711.                 szName,
  1712.                 pMetaData,
  1713.                 pbHashValue,
  1714.                 cbHashValue,
  1715.                 tkExecutionLocation,
  1716.                 dwAssemblyRefFlags,
  1717.                 pmdar);
  1718.     cycleCounterPause();
  1719.     logCall(err, "DefineAssemblyRef");
  1720.     return  err;
  1721. }
  1722.  
  1723. int     WAssemblyEmit::DefineManifestResource(
  1724.                 LPCWSTR     szName,
  1725.                 LPCWSTR     szDescription,
  1726.                 mdToken     tkImplementation,
  1727.                 DWORD       dwOffset,
  1728.                 LPCWSTR     szMIMEType,
  1729.                 LPCWSTR     szLocale,
  1730.                 DWORD       dwResourceFlags,
  1731.                 mdManifestResource  *pmdmr)
  1732. {
  1733.     cycleCounterResume();
  1734.     int     err = iase->DefineManifestResource(szName, szDescription, tkImplementation, dwOffset, szMIMEType, szLocale, dwResourceFlags, pmdmr);
  1735.     cycleCounterPause();
  1736.     logCall(err, "DefineManifestResource");
  1737.     return  err;
  1738. }
  1739.  
  1740. #if 0
  1741.  
  1742. int     WAssemblyEmit::DefineExecutionLocation(
  1743.                 LPCWSTR     szName,
  1744.                 LPCWSTR     szDescription,
  1745.                 LPCWSTR     szLocation,
  1746.                 DWORD       dwExecutionLocationFlags,
  1747.                 mdExecutionLocation *pmdel)
  1748. {
  1749.     cycleCounterResume();
  1750.     int     err = iase->;
  1751.     cycleCounterPause();
  1752.     logCall(err, "");
  1753.     return  err;
  1754. }
  1755.  
  1756. int     WAssemblyEmit::SetAssemblyRefProps(
  1757.                 mdAssemblyRef ar,
  1758.                 const void  *pbOriginator,
  1759.                 ULONG       cbOriginator,
  1760.                 LPCWSTR     szName,
  1761.                 const ASSEMBLYMETADATA *pMetaData,
  1762.                 const void  *pbHashValue,
  1763.                 ULONG       cbHashValue,
  1764.                 mdExecutionLocation tkExecutionLocation,
  1765.                 DWORD       dwAssemblyRefFlags)
  1766. {
  1767.     cycleCounterResume();
  1768.     int     err = iase->;
  1769.     cycleCounterPause();
  1770.     logCall(err, "");
  1771.     return  err;
  1772. }
  1773.  
  1774. int     WAssemblyEmit::SetFileProps(
  1775.                 mdFile      file,
  1776.                 const void  *pbHashValue,
  1777.                 ULONG       cbHashValue,
  1778.                 DWORD       dwFileFlags)
  1779. {
  1780.     cycleCounterResume();
  1781.     int     err = iase->;
  1782.     cycleCounterPause();
  1783.     logCall(err, "");
  1784.     return  err;
  1785. }
  1786.  
  1787. int     WAssemblyEmit::SetComTypeProps(
  1788.                 mdComType   ct,
  1789.                 LPCWSTR     szDescription,
  1790.                 mdToken     tkImplementation,
  1791.                 mdTypeDef   tkTypeDef,
  1792.                 mdExecutionLocation tkExecutionLocation,
  1793.                 DWORD       dwComTypeFlags)
  1794. {
  1795.     cycleCounterResume();
  1796.     int     err = iase->;
  1797.     cycleCounterPause();
  1798.     logCall(err, "");
  1799.     return  err;
  1800. }
  1801.  
  1802. #endif
  1803.  
  1804. /*****************************************************************************/
  1805.  
  1806. int     WMetaDataEmit::CreateSymbolWriter(LPCWSTR filename,
  1807.                                           WSymWriter **dbgWriter)
  1808. {
  1809.     ISymUnmanagedWriter *writer;
  1810.  
  1811.     int                  err;
  1812.  
  1813.  
  1814.     err = CoCreateInstance(CLSID_CorSymWriter,
  1815.                            NULL,
  1816.                            CLSCTX_INPROC_SERVER,
  1817.                            IID_ISymUnmanagedWriter,
  1818.                            (void **)&writer);
  1819.  
  1820.     logCall(err, "CreateSymbolWriter");
  1821.  
  1822.     if  (err)
  1823.     {
  1824.         *dbgWriter = NULL;
  1825.     }
  1826.     else
  1827.     {
  1828.         *dbgWriter = makeSYMWwrapper(writer);
  1829.  
  1830.         // Tell the symbol writer what metadata emitter it needs to be
  1831.         // working with.
  1832.         err = writer->Initialize((IUnknown*)imde,
  1833.                                  filename, NULL, TRUE);
  1834.         logCall(err, "SetEmitter");
  1835.     }
  1836.  
  1837.     return  err;
  1838. }
  1839.  
  1840. int     WSymWriter::DefineDocument(
  1841.                 LPCWSTR         wzFileName,
  1842.                 void          **pISymUnmanagedDocument)
  1843. {
  1844.     int     err = ((ISymUnmanagedWriter*)isw)->DefineDocument(
  1845.                         (LPWSTR)wzFileName,
  1846.                         &CorSym_LanguageType_SMC,
  1847.                         &CorSym_LanguageVendor_Microsoft,
  1848.                         &CorSym_DocumentType_Text,
  1849.                         (ISymUnmanagedDocumentWriter**)pISymUnmanagedDocument);
  1850.     logCall(err, "DefineDocument");
  1851.     return  err;
  1852. }
  1853.  
  1854. int     WSymWriter::OpenMethod(
  1855.                 mdMethodDef     methodToken)
  1856. {
  1857.     int     err = ((ISymUnmanagedWriter*)isw)->OpenMethod(methodToken);
  1858.     logCall(err, "OpenMethod");
  1859.     return  err;
  1860. }
  1861.  
  1862. int     WSymWriter::CloseMethod()
  1863. {
  1864.     int     err = ((ISymUnmanagedWriter*)isw)->CloseMethod();
  1865.     logCall(err, "CloseMethod");
  1866.     return  err;
  1867. }
  1868.  
  1869. int     WSymWriter::SetUserEntryPoint(mdMethodDef methodToken)
  1870. {
  1871.     int     err = ((ISymUnmanagedWriter*)isw)->SetUserEntryPoint(methodToken);
  1872.     logCall(err, "SetUserEntryPoint");
  1873.     return  err;
  1874. }
  1875.  
  1876. int     WSymWriter::OpenScope(unsigned startOffset, unsigned *scopeID)
  1877. {
  1878.     ULONG32 retScopeID = 0;
  1879.     int     err = ((ISymUnmanagedWriter*)isw)->OpenScope((ULONG32)startOffset,
  1880.                                                          &retScopeID);
  1881.     *scopeID = retScopeID;
  1882.     logCall(err, "OpenScope");
  1883.     return  err;
  1884. }
  1885.  
  1886. int     WSymWriter::CloseScope(unsigned endOffset)
  1887. {
  1888.     int     err = ((ISymUnmanagedWriter*)isw)->CloseScope(endOffset);
  1889.     logCall(err, "OpenScope");
  1890.     return  err;
  1891. }
  1892.  
  1893. int     WSymWriter::SetScopeRange(unsigned scopeID,
  1894.                                   unsigned startOffset,
  1895.                                   unsigned endOffset)
  1896. {
  1897.     int     err = ((ISymUnmanagedWriter*)isw)->SetScopeRange(scopeID,
  1898.                                                              startOffset,
  1899.                                                              endOffset);
  1900.     logCall(err, "SetScopeRange");
  1901.     return  err;
  1902. }
  1903.  
  1904. int     WSymWriter::DefineLocalVariable(
  1905.                 LPCWSTR         wzVariableName,
  1906.                 PCCOR_SIGNATURE sigPtr,
  1907.                 ULONG32         sigLen,
  1908.                 unsigned        slot)
  1909. {
  1910.     int     err = ((ISymUnmanagedWriter*)isw)->DefineLocalVariable(
  1911.                                                   (LPWSTR)wzVariableName,
  1912.                                                           0,
  1913.                                                           sigLen,
  1914.                                                    (BYTE*)sigPtr,
  1915.                                                           ADDR_IL_OFFSET,
  1916.                                                           slot,
  1917.                                                           0,
  1918.                                                           0,
  1919.                                                           0,
  1920.                                                           0);
  1921.     logCall(err, "DefineLocalVariable");
  1922.     return  err;
  1923. }
  1924.  
  1925. int     WSymWriter::DefineParameter(
  1926.                 LPCWSTR         wzVariableName,
  1927.                 unsigned        sequence)
  1928. {
  1929.     int     err = ((ISymUnmanagedWriter*)isw)->DefineParameter(
  1930.                                               (LPWSTR)wzVariableName,
  1931.                                                       0,
  1932.                                                       sequence,
  1933.                                                       ADDR_IL_OFFSET,
  1934.                                                       sequence,
  1935.                                                       0,
  1936.                                                       0);
  1937.     logCall(err, "DefineParameter");
  1938.     return  err;
  1939. }
  1940.  
  1941. int     WSymWriter::DefineSequencePoints(
  1942.                 void           *document,
  1943.                 ULONG32        spCount,
  1944.                 unsigned       *offsets,
  1945.                 unsigned       *lines)
  1946. {
  1947.     assert(sizeof(ULONG32) == sizeof(unsigned));
  1948.  
  1949.     int     err = ((ISymUnmanagedWriter*)isw)->DefineSequencePoints(
  1950.                                       (ISymUnmanagedDocumentWriter*)document,
  1951.                                       spCount,
  1952.                             (ULONG32*)offsets,
  1953.                             (ULONG32*)lines,
  1954.                                       NULL,
  1955.                                       NULL,
  1956.                                       NULL);
  1957.     logCall(err, "DefineSequencePoints");
  1958.     return  err;
  1959. }
  1960.  
  1961. int     WSymWriter::GetDebugInfo(IMAGE_DEBUG_DIRECTORY *pIDD,
  1962.                                  DWORD cData,
  1963.                                  DWORD *pcData,
  1964.                                  BYTE data[])
  1965. {
  1966.     int     err = ((ISymUnmanagedWriter*)isw)->GetDebugInfo(pIDD,
  1967.                                                             cData,
  1968.                                                             pcData,
  1969.                                                             data);
  1970.     logCall(err, "GetDebugInfo");
  1971.     return  err;
  1972. }
  1973.  
  1974. int     WSymWriter::Close(void)
  1975. {
  1976.     int     err = ((ISymUnmanagedWriter*)isw)->Close();
  1977.     logCall(err, "Close");
  1978.     return  err;
  1979. }
  1980.  
  1981. /*****************************************************************************/
  1982.  
  1983. WMetaDataDispenser * __stdcall  initializeIMD()
  1984. {
  1985.     /* Initialize COM and COR */
  1986.  
  1987.     if  (!CORinitialized)
  1988.     {
  1989.         CoInitialize(0);
  1990.         CoInitializeCor(COINITCOR_DEFAULT);
  1991.  
  1992.         CORinitialized = true;
  1993.     }
  1994.  
  1995.     /* Ask for the metadata metainterface */
  1996.  
  1997.     IMetaDataDispenser *imdd = NULL;
  1998.  
  1999.     if  (CoCreateInstance(CLSID_CorMetaDataDispenser,
  2000.                           NULL,
  2001.                           CLSCTX_INPROC_SERVER,
  2002.                           IID_IMetaDataDispenser, (void**)&imdd))
  2003.     {
  2004.         return  NULL;
  2005.     }
  2006.  
  2007. #if!MD_TOKEN_REMAP
  2008.  
  2009.     IMetaDataDispenserEx  * iex;
  2010.  
  2011.     if  (!imdd->QueryInterface(IID_IMetaDataDispenserEx, (void **)&iex))
  2012.     {
  2013.         VARIANT                 optv; optv.vt = VT_UI4;
  2014.  
  2015.         /* Check for duplicates of some tokens */
  2016.  
  2017.         optv.ulVal = MDDupSignature|MDDupMemberRef|MDDupModuleRef|MDDupTypeRef;
  2018.         iex->SetOption(MetaDataCheckDuplicatesFor   , &optv);
  2019.  
  2020.         /* Give error if emitting out of order */
  2021.  
  2022. #if     0
  2023. #ifdef  DEBUG
  2024.         optv.ulVal = MDErrorOutOfOrderAll;
  2025.         iex->SetOption(MetaDataErrorIfEmitOutOfOrder, &optv);
  2026. #endif
  2027. #endif
  2028.  
  2029.         iex->Release();
  2030.     }
  2031.  
  2032. #endif
  2033.  
  2034.     /* Return a wrapper */
  2035.  
  2036.     return  makeIMDDwrapper(imdd);
  2037. }
  2038.  
  2039. /*****************************************************************************/
  2040.  
  2041. ULONG       __stdcall WRAPPED_CorSigCompressData         (ULONG           iLen,  void           *pDataOut)
  2042. {
  2043.     return  CorSigCompressData(iLen, pDataOut);
  2044. }
  2045.  
  2046. ULONG       __stdcall WRAPPED_CorSigCompressToken        (mdToken         tk,    void           *pDataOut)
  2047. {
  2048.     return  CorSigCompressToken(tk, pDataOut);
  2049. }
  2050.  
  2051. ULONG       __stdcall WRAPPED_CorSigUncompressData       (PCCOR_SIGNATURE pData, ULONG          *pDataOut)
  2052. {
  2053.     return  CorSigUncompressData(pData, pDataOut);
  2054. }
  2055.  
  2056. ULONG       __stdcall WRAPPED_CorSigUncompressToken      (PCCOR_SIGNATURE pData, mdToken        *pToken)
  2057. {
  2058.     return  CorSigUncompressToken(pData, pToken);
  2059. }
  2060.  
  2061. ULONG       __stdcall WRAPPED_CorSigUncompressElementType(PCCOR_SIGNATURE pData, CorElementType *pElementType)
  2062. {
  2063.     return  CorSigUncompressElementType(pData, pElementType);
  2064. }
  2065.  
  2066. /*****************************************************************************/
  2067.  
  2068. CLS_EH_FAT* __stdcall WRAPPED_SectEH_EHClause (void       *   pSectEH,
  2069.                                                unsigned       idx,
  2070.                                                CLS_EH_FAT *   buff)
  2071. {
  2072.     return  SectEH_EHClause(pSectEH, idx, buff);
  2073. }
  2074.  
  2075. unsigned    __stdcall WRAPPED_SectEH_Emit     (unsigned       size,
  2076.                                      unsigned       ehCount,
  2077.                                      CLS_EH_FAT *   clauses,
  2078.                                      BOOL           moreSections,
  2079.                                      BYTE       *   outBuff)
  2080. {
  2081.     return  SectEH_Emit(size, ehCount, clauses, moreSections, outBuff);
  2082. }
  2083.  
  2084. unsigned    __stdcall WRAPPED_SectEH_SizeExact(unsigned       ehCount,
  2085.                                      CLS_EH_FAT *   clauses)
  2086. {
  2087.     return  SectEH_SizeExact(ehCount, clauses);
  2088. }
  2089.  
  2090. unsigned    __stdcall WRAPPED_IlmethodSize    (COR_IM_FAT *   header,
  2091.                                      BOOL           MoreSections)
  2092. {
  2093.     return  IlmethodSize(header, MoreSections);
  2094. }
  2095.  
  2096. unsigned    __stdcall WRAPPED_IlmethodEmit    (unsigned       size,
  2097.                                      COR_IM_FAT *   header,
  2098.                                      BOOL           moreSections,
  2099.                                      BYTE *         outBuff)
  2100. {
  2101.     return  IlmethodEmit(size, header, moreSections, outBuff);
  2102. }
  2103.  
  2104. /*****************************************************************************/
  2105.  
  2106. #include "strongname.h"
  2107.  
  2108. __declspec(dllexport)
  2109. HRESULT __stdcall WRAPPED_GetHashFromFile(LPCSTR    szFilePath,
  2110.                                           unsigned *iHashAlg,
  2111.                                           BYTE     *pbHash,
  2112.                                           DWORD     cchHash,
  2113.                                           DWORD    *pchHash)
  2114. {
  2115.     return  GetHashFromFile(szFilePath, iHashAlg, pbHash, cchHash, pchHash);
  2116. }
  2117.  
  2118. /*****************************************************************************/
  2119.