?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
janitorial: Close COM after tests.
[wine.git] / dlls / oleaut32 / typelib.c
blob43aedc5a056e521643590d7ca2c289e67c461e3b
1 /*
2 * TYPELIB
3 *
4 * Copyright 1997 Marcus Meissner
5 * 1999 Rein Klazes
6 * 2000 Francois Jacques
7 * 2001 Huw D M Davies for CodeWeavers
8 * 2005 Robert Shearman, for CodeWeavers
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 *
24 * --------------------------------------------------------------------------------------
25 * Known problems (2000, Francois Jacques)
26 *
27 * - Tested using OLEVIEW (Platform SDK tool) only.
28 *
29 * - dual interface dispinterfaces. vtable-interface ITypeInfo instances are
30 * creating by doing a straight copy of the dispinterface instance and just changing
31 * its typekind. Pointed structures aren't copied - only the address of the pointers.
32 *
33 * - locale stuff is partially implemented but hasn't been tested.
34 *
35 * - typelib file is still read in its entirety, but it is released now.
36 *
37 * --------------------------------------------------------------------------------------
38 * Known problems left from previous implementation (1999, Rein Klazes) :
39 *
40 * -. Data structures are straightforward, but slow for look-ups.
41 * -. (related) nothing is hashed
42 * -. Most error return values are just guessed not checked with windows
43 * behaviour.
44 * -. lousy fatal error handling
45 *
46 */
47
48 #include "config.h"
49 #include "wine/port.h"
50
51 #include <stdlib.h>
52 #include <string.h>
53 #include <stdarg.h>
54 #include <stdio.h>
55 #include <ctype.h>
56
57 #define COBJMACROS
58 #define NONAMELESSUNION
59 #define NONAMELESSSTRUCT
60
61 #include "winerror.h"
62 #include "windef.h"
63 #include "winbase.h"
64 #include "winnls.h"
65 #include "winreg.h"
66 #include "winuser.h"
67
68 #include "wine/unicode.h"
69 #include "objbase.h"
70 #include "typelib.h"
71 #include "wine/debug.h"
72 #include "variant.h"
73 #include "wine/list.h"
74
75 WINE_DEFAULT_DEBUG_CHANNEL(ole);
76 WINE_DECLARE_DEBUG_CHANNEL(typelib);
77
78 static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt);
79 static HRESULT TLB_AllocAndInitVarDesc(const VARDESC *src, VARDESC **dest_ptr);
80
81 /****************************************************************************
82 * FromLExxx
83 *
84 * Takes p_iVal (which is in little endian) and returns it
85 * in the host machine's byte order.
86 */
87 #ifdef WORDS_BIGENDIAN
88 static WORD FromLEWord(WORD p_iVal)
89 {
90 return (((p_iVal & 0x00FF) << 8) |
91 ((p_iVal & 0xFF00) >> 8));
92 }
93
94
95 static DWORD FromLEDWord(DWORD p_iVal)
96 {
97 return (((p_iVal & 0x000000FF) << 24) |
98 ((p_iVal & 0x0000FF00) << 8) |
99 ((p_iVal & 0x00FF0000) >> 8) |
100 ((p_iVal & 0xFF000000) >> 24));
101 }
102 #else
103 #define FromLEWord(X) (X)
104 #define FromLEDWord(X) (X)
105 #endif
106
107 #define DISPATCH_HREF_OFFSET 0x01000000
108 #define DISPATCH_HREF_MASK 0xff000000
109
110 /****************************************************************************
111 * FromLExxx
112 *
113 * Fix byte order in any structure if necessary
114 */
115 #ifdef WORDS_BIGENDIAN
116 static void FromLEWords(void *p_Val, int p_iSize)
117 {
118 WORD *Val = p_Val;
119
120 p_iSize /= sizeof(WORD);
121
122 while (p_iSize) {
123 *Val = FromLEWord(*Val);
124 Val++;
125 p_iSize--;
126 }
127 }
128
129
130 static void FromLEDWords(void *p_Val, int p_iSize)
131 {
132 DWORD *Val = p_Val;
133
134 p_iSize /= sizeof(DWORD);
135
136 while (p_iSize) {
137 *Val = FromLEDWord(*Val);
138 Val++;
139 p_iSize--;
140 }
141 }
142 #else
143 #define FromLEWords(X,Y) /*nothing*/
144 #define FromLEDWords(X,Y) /*nothing*/
145 #endif
146
147 /*
148 * Find a typelib key which matches a requested maj.min version.
149 */
150 static BOOL find_typelib_key( REFGUID guid, WORD wMaj, WORD *wMin )
151 {
152 static const WCHAR typelibW[] = {'T','y','p','e','l','i','b','\\',0};
153 WCHAR buffer[60];
154 char key_name[16];
155 DWORD len, i;
156 INT best_min = -1;
157 HKEY hkey;
158
159 memcpy( buffer, typelibW, sizeof(typelibW) );
160 StringFromGUID2( guid, buffer + strlenW(buffer), 40 );
161
162 if (RegOpenKeyExW( HKEY_CLASSES_ROOT, buffer, 0, KEY_READ, &hkey ) != ERROR_SUCCESS)
163 return FALSE;
164
165 len = sizeof(key_name);
166 i = 0;
167 while (RegEnumKeyExA(hkey, i++, key_name, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
168 {
169 INT v_maj, v_min;
170
171 if (sscanf(key_name, "%x.%x", &v_maj, &v_min) == 2)
172 {
173 TRACE("found %s: %x.%x\n", debugstr_w(buffer), v_maj, v_min);
174
175 if (wMaj == v_maj)
176 {
177 if (*wMin == v_min)
178 {
179 best_min = v_min;
180 break; /* exact match */
181 }
182 if (v_min > best_min) best_min = v_min;
183 }
184 }
185 len = sizeof(key_name);
186 }
187 RegCloseKey( hkey );
188 if (best_min >= 0)
189 {
190 *wMin = best_min;
191 return TRUE;
192 }
193 return FALSE;
194 }
195
196 /* get the path of a typelib key, in the form "Typelib\\<guid>\\<maj>.<min>" */
197 /* buffer must be at least 60 characters long */
198 static WCHAR *get_typelib_key( REFGUID guid, WORD wMaj, WORD wMin, WCHAR *buffer )
199 {
200 static const WCHAR TypelibW[] = {'T','y','p','e','l','i','b','\\',0};
201 static const WCHAR VersionFormatW[] = {'\\','%','x','.','%','x',0};
202
203 memcpy( buffer, TypelibW, sizeof(TypelibW) );
204 StringFromGUID2( guid, buffer + strlenW(buffer), 40 );
205 sprintfW( buffer + strlenW(buffer), VersionFormatW, wMaj, wMin );
206 return buffer;
207 }
208
209 /* get the path of an interface key, in the form "Interface\\<guid>" */
210 /* buffer must be at least 50 characters long */
211 static WCHAR *get_interface_key( REFGUID guid, WCHAR *buffer )
212 {
213 static const WCHAR InterfaceW[] = {'I','n','t','e','r','f','a','c','e','\\',0};
214
215 memcpy( buffer, InterfaceW, sizeof(InterfaceW) );
216 StringFromGUID2( guid, buffer + strlenW(buffer), 40 );
217 return buffer;
218 }
219
220 /* get the lcid subkey for a typelib, in the form "<lcid>\\<syskind>" */
221 /* buffer must be at least 16 characters long */
222 static WCHAR *get_lcid_subkey( LCID lcid, SYSKIND syskind, WCHAR *buffer )
223 {
224 static const WCHAR LcidFormatW[] = {'%','l','x','\\',0};
225 static const WCHAR win16W[] = {'w','i','n','1','6',0};
226 static const WCHAR win32W[] = {'w','i','n','3','2',0};
227
228 sprintfW( buffer, LcidFormatW, lcid );
229 switch(syskind)
230 {
231 case SYS_WIN16: strcatW( buffer, win16W ); break;
232 case SYS_WIN32: strcatW( buffer, win32W ); break;
233 default:
234 TRACE("Typelib is for unsupported syskind %i\n", syskind);
235 return NULL;
236 }
237 return buffer;
238 }
239
240 static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath, ITypeLib2 **ppTypeLib);
241
242
243 /****************************************************************************
244 * QueryPathOfRegTypeLib [OLEAUT32.164]
245 *
246 * Gets the path to a registered type library.
247 *
248 * PARAMS
249 * guid [I] referenced guid
250 * wMaj [I] major version
251 * wMin [I] minor version
252 * lcid [I] locale id
253 * path [O] path of typelib
254 *
255 * RETURNS
256 * Success: S_OK.
257 * Failure: If the type library is not registered then TYPE_E_LIBNOTREGISTERED
258 * or TYPE_E_REGISTRYACCESS if the type library registration key couldn't be
259 * opened.
260 */
261 HRESULT WINAPI QueryPathOfRegTypeLib(
262 REFGUID guid,
263 WORD wMaj,
264 WORD wMin,
265 LCID lcid,
266 LPBSTR path )
267 {
268 HRESULT hr = TYPE_E_LIBNOTREGISTERED;
269 LCID myLCID = lcid;
270 HKEY hkey;
271 WCHAR buffer[60];
272 WCHAR Path[MAX_PATH];
273 LONG res;
274
275 TRACE_(typelib)("(%s, %x.%x, 0x%x, %p)\n", debugstr_guid(guid), wMaj, wMin, lcid, path);
276
277 if (!find_typelib_key( guid, wMaj, &wMin )) return TYPE_E_LIBNOTREGISTERED;
278 get_typelib_key( guid, wMaj, wMin, buffer );
279
280 res = RegOpenKeyExW( HKEY_CLASSES_ROOT, buffer, 0, KEY_READ, &hkey );
281 if (res == ERROR_FILE_NOT_FOUND)
282 {
283 TRACE_(typelib)("%s not found\n", debugstr_w(buffer));
284 return TYPE_E_LIBNOTREGISTERED;
285 }
286 else if (res != ERROR_SUCCESS)
287 {
288 TRACE_(typelib)("failed to open %s for read access\n", debugstr_w(buffer));
289 return TYPE_E_REGISTRYACCESS;
290 }
291
292 while (hr != S_OK)
293 {
294 LONG dwPathLen = sizeof(Path);
295
296 get_lcid_subkey( myLCID, SYS_WIN32, buffer );
297
298 if (RegQueryValueW(hkey, buffer, Path, &dwPathLen))
299 {
300 if (!lcid)
301 break;
302 else if (myLCID == lcid)
303 {
304 /* try with sub-langid */
305 myLCID = SUBLANGID(lcid);
306 }
307 else if ((myLCID == SUBLANGID(lcid)) && myLCID)
308 {
309 /* try with system langid */
310 myLCID = 0;
311 }
312 else
313 {
314 break;
315 }
316 }
317 else
318 {
319 *path = SysAllocString( Path );
320 hr = S_OK;
321 }
322 }
323 RegCloseKey( hkey );
324 TRACE_(typelib)("-- 0x%08x\n", hr);
325 return hr;
326 }
327
328 /******************************************************************************
329 * CreateTypeLib [OLEAUT32.160] creates a typelib
330 *
331 * RETURNS
332 * Success: S_OK
333 * Failure: Status
334 */
335 HRESULT WINAPI CreateTypeLib(
336 SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib** ppctlib
337 ) {
338 FIXME("(%d,%s,%p), stub!\n",syskind,debugstr_w(szFile),ppctlib);
339 return E_FAIL;
340 }
341
342 /******************************************************************************
343 * LoadTypeLib [OLEAUT32.161]
344 *
345 * Loads a type library
346 *
347 * PARAMS
348 * szFile [I] Name of file to load from.
349 * pptLib [O] Pointer that receives ITypeLib object on success.
350 *
351 * RETURNS
352 * Success: S_OK
353 * Failure: Status
354 *
355 * SEE
356 * LoadTypeLibEx, LoadRegTypeLib, CreateTypeLib.
357 */
358 HRESULT WINAPI LoadTypeLib(const OLECHAR *szFile, ITypeLib * *pptLib)
359 {
360 TRACE("(%s,%p)\n",debugstr_w(szFile), pptLib);
361 return LoadTypeLibEx(szFile, REGKIND_DEFAULT, pptLib);
362 }
363
364 /******************************************************************************
365 * LoadTypeLibEx [OLEAUT32.183]
366 *
367 * Loads and optionally registers a type library
368 *
369 * RETURNS
370 * Success: S_OK
371 * Failure: Status
372 */
373 HRESULT WINAPI LoadTypeLibEx(
374 LPCOLESTR szFile, /* [in] Name of file to load from */
375 REGKIND regkind, /* [in] Specify kind of registration */
376 ITypeLib **pptLib) /* [out] Pointer to pointer to loaded type library */
377 {
378 WCHAR szPath[MAX_PATH+1];
379 HRESULT res;
380
381 TRACE("(%s,%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
382
383 *pptLib = NULL;
384
385 res = TLB_ReadTypeLib(szFile, szPath, MAX_PATH + 1, (ITypeLib2**)pptLib);
386
387 if (SUCCEEDED(res))
388 switch(regkind)
389 {
390 case REGKIND_DEFAULT:
391 /* don't register typelibs supplied with full path. Experimentation confirms the following */
392 if (((szFile[0] == '\\') && (szFile[1] == '\\')) ||
393 (szFile[0] && (szFile[1] == ':'))) break;
394 /* else fall-through */
395
396 case REGKIND_REGISTER:
397 if (!SUCCEEDED(res = RegisterTypeLib(*pptLib, (LPOLESTR)szPath, NULL)))
398 {
399 IUnknown_Release(*pptLib);
400 *pptLib = 0;
401 }
402 break;
403 case REGKIND_NONE:
404 break;
405 }
406
407 TRACE(" returns %08x\n",res);
408 return res;
409 }
410
411 /******************************************************************************
412 * LoadRegTypeLib [OLEAUT32.162]
413 *
414 * Loads a registered type library.
415 *
416 * PARAMS
417 * rguid [I] GUID of the registered type library.
418 * wVerMajor [I] major version.
419 * wVerMinor [I] minor version.
420 * lcid [I] locale ID.
421 * ppTLib [O] pointer that receives an ITypeLib object on success.
422 *
423 * RETURNS
424 * Success: S_OK.
425 * Failure: Any HRESULT code returned from QueryPathOfRegTypeLib or
426 * LoadTypeLib.
427 */
428 HRESULT WINAPI LoadRegTypeLib(
429 REFGUID rguid,
430 WORD wVerMajor,
431 WORD wVerMinor,
432 LCID lcid,
433 ITypeLib **ppTLib)
434 {
435 BSTR bstr=NULL;
436 HRESULT res;
437
438 *ppTLib = NULL;
439
440 res = QueryPathOfRegTypeLib( rguid, wVerMajor, wVerMinor, lcid, &bstr);
441
442 if(SUCCEEDED(res))
443 {
444 res= LoadTypeLib(bstr, ppTLib);
445 SysFreeString(bstr);
446 }
447
448 TRACE("(IID: %s) load %s (%p)\n",debugstr_guid(rguid), SUCCEEDED(res)? "SUCCESS":"FAILED", *ppTLib);
449
450 return res;
451 }
452
453
454 /* some string constants shared between RegisterTypeLib and UnRegisterTypeLib */
455 static const WCHAR TypeLibW[] = {'T','y','p','e','L','i','b',0};
456 static const WCHAR FLAGSW[] = {'F','L','A','G','S',0};
457 static const WCHAR HELPDIRW[] = {'H','E','L','P','D','I','R',0};
458 static const WCHAR ProxyStubClsidW[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d',0};
459 static const WCHAR ProxyStubClsid32W[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0};
460
461 /******************************************************************************
462 * RegisterTypeLib [OLEAUT32.163]
463 * Adds information about a type library to the System Registry
464 * NOTES
465 * Docs: ITypeLib FAR * ptlib
466 * Docs: OLECHAR FAR* szFullPath
467 * Docs: OLECHAR FAR* szHelpDir
468 *
469 * RETURNS
470 * Success: S_OK
471 * Failure: Status
472 */
473 HRESULT WINAPI RegisterTypeLib(
474 ITypeLib * ptlib, /* [in] Pointer to the library*/
475 OLECHAR * szFullPath, /* [in] full Path of the library*/
476 OLECHAR * szHelpDir) /* [in] dir to the helpfile for the library,
477 may be NULL*/
478 {
479 static const WCHAR PSOA[] = {'{','0','0','0','2','0','4','2','4','-',
480 '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-',
481 '0','0','0','0','0','0','0','0','0','0','4','6','}',0};
482 HRESULT res;
483 TLIBATTR *attr;
484 WCHAR keyName[60];
485 WCHAR tmp[16];
486 HKEY key, subKey;
487 UINT types, tidx;
488 TYPEKIND kind;
489 DWORD disposition;
490
491 if (ptlib == NULL || szFullPath == NULL)
492 return E_INVALIDARG;
493
494 if (!SUCCEEDED(ITypeLib_GetLibAttr(ptlib, &attr)))
495 return E_FAIL;
496
497 get_typelib_key( &attr->guid, attr->wMajorVerNum, attr->wMinorVerNum, keyName );
498
499 res = S_OK;
500 if (RegCreateKeyExW(HKEY_CLASSES_ROOT, keyName, 0, NULL, 0,
501 KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS)
502 {
503 LPOLESTR doc;
504
505 /* Set the human-readable name of the typelib */
506 if (SUCCEEDED(ITypeLib_GetDocumentation(ptlib, -1, NULL, &doc, NULL, NULL)))
507 {
508 if (RegSetValueExW(key, NULL, 0, REG_SZ,
509 (BYTE *)doc, (lstrlenW(doc)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS)
510 res = E_FAIL;
511
512 SysFreeString(doc);
513 }
514 else
515 res = E_FAIL;
516
517 /* Make up the name of the typelib path subkey */
518 if (!get_lcid_subkey( attr->lcid, attr->syskind, tmp )) res = E_FAIL;
519
520 /* Create the typelib path subkey */
521 if (res == S_OK && RegCreateKeyExW(key, tmp, 0, NULL, 0,
522 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
523 {
524 if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
525 (BYTE *)szFullPath, (lstrlenW(szFullPath)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS)
526 res = E_FAIL;
527
528 RegCloseKey(subKey);
529 }
530 else
531 res = E_FAIL;
532
533 /* Create the flags subkey */
534 if (res == S_OK && RegCreateKeyExW(key, FLAGSW, 0, NULL, 0,
535 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
536 {
537 /* FIXME: is %u correct? */
538 static const WCHAR formatW[] = {'%','u',0};
539 WCHAR buf[20];
540 sprintfW(buf, formatW, attr->wLibFlags);
541 if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
542 (BYTE *)buf, (strlenW(buf) + 1)*sizeof(WCHAR) ) != ERROR_SUCCESS)
543 res = E_FAIL;
544
545 RegCloseKey(subKey);
546 }
547 else
548 res = E_FAIL;
549
550 /* create the helpdir subkey */
551 if (res == S_OK && RegCreateKeyExW(key, HELPDIRW, 0, NULL, 0,
552 KEY_WRITE, NULL, &subKey, &disposition) == ERROR_SUCCESS)
553 {
554 BOOL freeHelpDir = FALSE;
555 OLECHAR* pIndexStr;
556
557 /* if we created a new key, and helpDir was null, set the helpdir
558 to the directory which contains the typelib. However,
559 if we just opened an existing key, we leave the helpdir alone */
560 if ((disposition == REG_CREATED_NEW_KEY) && (szHelpDir == NULL)) {
561 szHelpDir = SysAllocString(szFullPath);
562 pIndexStr = strrchrW(szHelpDir, '\\');
563 if (pIndexStr) {
564 *pIndexStr = 0;
565 }
566 freeHelpDir = TRUE;
567 }
568
569 /* if we have an szHelpDir, set it! */
570 if (szHelpDir != NULL) {
571 if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
572 (BYTE *)szHelpDir, (lstrlenW(szHelpDir)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS) {
573 res = E_FAIL;
574 }
575 }
576
577 /* tidy up */
578 if (freeHelpDir) SysFreeString(szHelpDir);
579 RegCloseKey(subKey);
580
581 } else {
582 res = E_FAIL;
583 }
584
585 RegCloseKey(key);
586 }
587 else
588 res = E_FAIL;
589
590 /* register OLE Automation-compatible interfaces for this typelib */
591 types = ITypeLib_GetTypeInfoCount(ptlib);
592 for (tidx=0; tidx<types; tidx++) {
593 if (SUCCEEDED(ITypeLib_GetTypeInfoType(ptlib, tidx, &kind))) {
594 LPOLESTR name = NULL;
595 ITypeInfo *tinfo = NULL;
596
597 ITypeLib_GetDocumentation(ptlib, tidx, &name, NULL, NULL, NULL);
598
599 switch (kind) {
600 case TKIND_INTERFACE:
601 TRACE_(typelib)("%d: interface %s\n", tidx, debugstr_w(name));
602 ITypeLib_GetTypeInfo(ptlib, tidx, &tinfo);
603 break;
604
605 case TKIND_DISPATCH:
606 TRACE_(typelib)("%d: dispinterface %s\n", tidx, debugstr_w(name));
607 ITypeLib_GetTypeInfo(ptlib, tidx, &tinfo);
608 break;
609
610 default:
611 TRACE_(typelib)("%d: %s\n", tidx, debugstr_w(name));
612 break;
613 }
614
615 if (tinfo) {
616 TYPEATTR *tattr = NULL;
617 ITypeInfo_GetTypeAttr(tinfo, &tattr);
618
619 if (tattr) {
620 TRACE_(typelib)("guid=%s, flags=%04x (",
621 debugstr_guid(&tattr->guid),
622 tattr->wTypeFlags);
623
624 if (TRACE_ON(typelib)) {
625 #define XX(x) if (TYPEFLAG_##x & tattr->wTypeFlags) MESSAGE(#x"|");
626 XX(FAPPOBJECT);
627 XX(FCANCREATE);
628 XX(FLICENSED);
629 XX(FPREDECLID);
630 XX(FHIDDEN);
631 XX(FCONTROL);
632 XX(FDUAL);
633 XX(FNONEXTENSIBLE);
634 XX(FOLEAUTOMATION);
635 XX(FRESTRICTED);
636 XX(FAGGREGATABLE);
637 XX(FREPLACEABLE);
638 XX(FDISPATCHABLE);
639 XX(FREVERSEBIND);
640 XX(FPROXY);
641 #undef XX
642 MESSAGE("\n");
643 }
644
645 if (tattr->wTypeFlags & (TYPEFLAG_FOLEAUTOMATION|TYPEFLAG_FDUAL|TYPEFLAG_FDISPATCHABLE))
646 {
647 /* register interface<->typelib coupling */
648 get_interface_key( &tattr->guid, keyName );
649 if (RegCreateKeyExW(HKEY_CLASSES_ROOT, keyName, 0, NULL, 0,
650 KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS)
651 {
652 if (name)
653 RegSetValueExW(key, NULL, 0, REG_SZ,
654 (BYTE *)name, (strlenW(name)+1) * sizeof(OLECHAR));
655
656 if (RegCreateKeyExW(key, ProxyStubClsidW, 0, NULL, 0,
657 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS) {
658 RegSetValueExW(subKey, NULL, 0, REG_SZ,
659 (const BYTE *)PSOA, sizeof PSOA);
660 RegCloseKey(subKey);
661 }
662
663 if (RegCreateKeyExW(key, ProxyStubClsid32W, 0, NULL, 0,
664 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS) {
665 RegSetValueExW(subKey, NULL, 0, REG_SZ,
666 (const BYTE *)PSOA, sizeof PSOA);
667 RegCloseKey(subKey);
668 }
669
670 if (RegCreateKeyExW(key, TypeLibW, 0, NULL, 0,
671 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
672 {
673 WCHAR buffer[40];
674 static const WCHAR fmtver[] = {'%','x','.','%','x',0 };
675 static const WCHAR VersionW[] = {'V','e','r','s','i','o','n',0};
676
677 StringFromGUID2(&attr->guid, buffer, 40);
678 RegSetValueExW(subKey, NULL, 0, REG_SZ,
679 (BYTE *)buffer, (strlenW(buffer)+1) * sizeof(WCHAR));
680 sprintfW(buffer, fmtver, attr->wMajorVerNum, attr->wMinorVerNum);
681 RegSetValueExW(subKey, VersionW, 0, REG_SZ,
682 (BYTE*)buffer, (strlenW(buffer)+1) * sizeof(WCHAR));
683 RegCloseKey(subKey);
684 }
685
686 RegCloseKey(key);
687 }
688 }
689
690 ITypeInfo_ReleaseTypeAttr(tinfo, tattr);
691 }
692
693 ITypeInfo_Release(tinfo);
694 }
695
696 SysFreeString(name);
697 }
698 }
699
700 ITypeLib_ReleaseTLibAttr(ptlib, attr);
701
702 return res;
703 }
704
705
706 /******************************************************************************
707 * UnRegisterTypeLib [OLEAUT32.186]
708 * Removes information about a type library from the System Registry
709 * NOTES
710 *
711 * RETURNS
712 * Success: S_OK
713 * Failure: Status
714 */
715 HRESULT WINAPI UnRegisterTypeLib(
716 REFGUID libid, /* [in] Guid of the library */
717 WORD wVerMajor, /* [in] major version */
718 WORD wVerMinor, /* [in] minor version */
719 LCID lcid, /* [in] locale id */
720 SYSKIND syskind)
721 {
722 BSTR tlibPath = NULL;
723 DWORD tmpLength;
724 WCHAR keyName[60];
725 WCHAR subKeyName[50];
726 int result = S_OK;
727 DWORD i = 0;
728 BOOL deleteOtherStuff;
729 HKEY key = NULL;
730 HKEY subKey = NULL;
731 TYPEATTR* typeAttr = NULL;
732 TYPEKIND kind;
733 ITypeInfo* typeInfo = NULL;
734 ITypeLib* typeLib = NULL;
735 int numTypes;
736
737 TRACE("(IID: %s)\n",debugstr_guid(libid));
738
739 /* Create the path to the key */
740 get_typelib_key( libid, wVerMajor, wVerMinor, keyName );
741
742 if (syskind != SYS_WIN16 && syskind != SYS_WIN32)
743 {
744 TRACE("Unsupported syskind %i\n", syskind);
745 result = E_INVALIDARG;
746 goto end;
747 }
748
749 /* get the path to the typelib on disk */
750 if (QueryPathOfRegTypeLib(libid, wVerMajor, wVerMinor, lcid, &tlibPath) != S_OK) {
751 result = E_INVALIDARG;
752 goto end;
753 }
754
755 /* Try and open the key to the type library. */
756 if (RegOpenKeyExW(HKEY_CLASSES_ROOT, keyName, 0, KEY_READ | KEY_WRITE, &key) != ERROR_SUCCESS) {
757 result = E_INVALIDARG;
758 goto end;
759 }
760
761 /* Try and load the type library */
762 if (LoadTypeLibEx(tlibPath, REGKIND_NONE, &typeLib)) {
763 result = TYPE_E_INVALIDSTATE;
764 goto end;
765 }
766
767 /* remove any types registered with this typelib */
768 numTypes = ITypeLib_GetTypeInfoCount(typeLib);
769 for (i=0; i<numTypes; i++) {
770 /* get the kind of type */
771 if (ITypeLib_GetTypeInfoType(typeLib, i, &kind) != S_OK) {
772 goto enddeleteloop;
773 }
774
775 /* skip non-interfaces, and get type info for the type */
776 if ((kind != TKIND_INTERFACE) && (kind != TKIND_DISPATCH)) {
777 goto enddeleteloop;
778 }
779 if (ITypeLib_GetTypeInfo(typeLib, i, &typeInfo) != S_OK) {
780 goto enddeleteloop;
781 }
782 if (ITypeInfo_GetTypeAttr(typeInfo, &typeAttr) != S_OK) {
783 goto enddeleteloop;
784 }
785
786 /* the path to the type */
787 get_interface_key( &typeAttr->guid, subKeyName );
788
789 /* Delete its bits */
790 if (RegOpenKeyExW(HKEY_CLASSES_ROOT, subKeyName, 0, KEY_WRITE, &subKey) != ERROR_SUCCESS) {
791 goto enddeleteloop;
792 }
793 RegDeleteKeyW(subKey, ProxyStubClsidW);
794 RegDeleteKeyW(subKey, ProxyStubClsid32W);
795 RegDeleteKeyW(subKey, TypeLibW);
796 RegCloseKey(subKey);
797 subKey = NULL;
798 RegDeleteKeyW(HKEY_CLASSES_ROOT, subKeyName);
799
800 enddeleteloop:
801 if (typeAttr) ITypeInfo_ReleaseTypeAttr(typeInfo, typeAttr);
802 typeAttr = NULL;
803 if (typeInfo) ITypeInfo_Release(typeInfo);
804 typeInfo = NULL;
805 }
806
807 /* Now, delete the type library path subkey */
808 get_lcid_subkey( lcid, syskind, subKeyName );
809 RegDeleteKeyW(key, subKeyName);
810 *strrchrW( subKeyName, '\\' ) = 0; /* remove last path component */
811 RegDeleteKeyW(key, subKeyName);
812
813 /* check if there is anything besides the FLAGS/HELPDIR keys.
814 If there is, we don't delete them */
815 tmpLength = sizeof(subKeyName)/sizeof(WCHAR);
816 deleteOtherStuff = TRUE;
817 i = 0;
818 while(RegEnumKeyExW(key, i++, subKeyName, &tmpLength, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
819 tmpLength = sizeof(subKeyName)/sizeof(WCHAR);
820
821 /* if its not FLAGS or HELPDIR, then we must keep the rest of the key */
822 if (!strcmpW(subKeyName, FLAGSW)) continue;
823 if (!strcmpW(subKeyName, HELPDIRW)) continue;
824 deleteOtherStuff = FALSE;
825 break;
826 }
827
828 /* only delete the other parts of the key if we're absolutely sure */
829 if (deleteOtherStuff) {
830 RegDeleteKeyW(key, FLAGSW);
831 RegDeleteKeyW(key, HELPDIRW);
832 RegCloseKey(key);
833 key = NULL;
834
835 RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName);
836 *strrchrW( keyName, '\\' ) = 0; /* remove last path component */
837 RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName);
838 }
839
840 end:
841 if (tlibPath) SysFreeString(tlibPath);
842 if (typeLib) ITypeLib_Release(typeLib);
843 if (subKey) RegCloseKey(subKey);
844 if (key) RegCloseKey(key);
845 return result;
846 }
847
848 /*======================= ITypeLib implementation =======================*/
849
850 typedef struct tagTLBCustData
851 {
852 GUID guid;
853 VARIANT data;
854 struct tagTLBCustData* next;
855 } TLBCustData;
856
857 /* data structure for import typelibs */
858 typedef struct tagTLBImpLib
859 {
860 int offset; /* offset in the file (MSFT)
861 offset in nametable (SLTG)
862 just used to identify library while reading
863 data from file */
864 GUID guid; /* libid */
865 BSTR name; /* name */
866
867 LCID lcid; /* lcid of imported typelib */
868
869 WORD wVersionMajor; /* major version number */
870 WORD wVersionMinor; /* minor version number */
871
872 struct tagITypeLibImpl *pImpTypeLib; /* pointer to loaded typelib, or
873 NULL if not yet loaded */
874 struct tagTLBImpLib * next;
875 } TLBImpLib;
876
877 /* internal ITypeLib data */
878 typedef struct tagITypeLibImpl
879 {
880 const ITypeLib2Vtbl *lpVtbl;
881 const ITypeCompVtbl *lpVtblTypeComp;
882 LONG ref;
883 TLIBATTR LibAttr; /* guid,lcid,syskind,version,flags */
884
885 /* strings can be stored in tlb as multibyte strings BUT they are *always*
886 * exported to the application as a UNICODE string.
887 */
888 BSTR Name;
889 BSTR DocString;
890 BSTR HelpFile;
891 BSTR HelpStringDll;
892 unsigned long dwHelpContext;
893 int TypeInfoCount; /* nr of typeinfo's in librarry */
894 struct tagITypeInfoImpl *pTypeInfo; /* linked list of type info data */
895 int ctCustData; /* number of items in cust data list */
896 TLBCustData * pCustData; /* linked list to cust data */
897 TLBImpLib * pImpLibs; /* linked list to all imported typelibs */
898 int ctTypeDesc; /* number of items in type desc array */
899 TYPEDESC * pTypeDesc; /* array of TypeDescriptions found in the
900 library. Only used while reading MSFT
901 typelibs */
902 struct list ref_list; /* list of ref types in this typelib */
903 HREFTYPE dispatch_href; /* reference to IDispatch, -1 if unused */
904
905
906 /* typelibs are cached, keyed by path and index, so store the linked list info within them */
907 struct tagITypeLibImpl *next, *prev;
908 WCHAR *path;
909 INT index;
910 } ITypeLibImpl;
911
912 static const ITypeLib2Vtbl tlbvt;
913 static const ITypeCompVtbl tlbtcvt;
914
915 static inline ITypeLibImpl *impl_from_ITypeComp( ITypeComp *iface )
916 {
917 return (ITypeLibImpl *)((char*)iface - FIELD_OFFSET(ITypeLibImpl, lpVtblTypeComp));
918 }
919
920 /* ITypeLib methods */
921 static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength);
922 static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength);
923
924 /*======================= ITypeInfo implementation =======================*/
925
926 /* data for referenced types */
927 typedef struct tagTLBRefType
928 {
929 INT index; /* Type index for internal ref or for external ref
930 it the format is SLTG. -2 indicates to
931 use guid */
932
933 GUID guid; /* guid of the referenced type */
934 /* if index == TLB_REF_USE_GUID */
935
936 HREFTYPE reference; /* The href of this ref */
937 TLBImpLib *pImpTLInfo; /* If ref is external ptr to library data
938 TLB_REF_INTERNAL for internal refs
939 TLB_REF_NOT_FOUND for broken refs */
940
941 struct list entry;
942 } TLBRefType;
943
944 #define TLB_REF_USE_GUID -2
945
946 #define TLB_REF_INTERNAL (void*)-2
947 #define TLB_REF_NOT_FOUND (void*)-1
948
949 /* internal Parameter data */
950 typedef struct tagTLBParDesc
951 {
952 BSTR Name;
953 int ctCustData;
954 TLBCustData * pCustData; /* linked list to cust data */
955 } TLBParDesc;
956
957 /* internal Function data */
958 typedef struct tagTLBFuncDesc
959 {
960 FUNCDESC funcdesc; /* lots of info on the function and its attributes. */
961 BSTR Name; /* the name of this function */
962 TLBParDesc *pParamDesc; /* array with param names and custom data */
963 int helpcontext;
964 int HelpStringContext;
965 BSTR HelpString;
966 BSTR Entry; /* if its Hiword==0, it numeric; -1 is not present*/
967 int ctCustData;
968 TLBCustData * pCustData; /* linked list to cust data; */
969 struct tagTLBFuncDesc * next;
970 } TLBFuncDesc;
971
972 /* internal Variable data */
973 typedef struct tagTLBVarDesc
974 {
975 VARDESC vardesc; /* lots of info on the variable and its attributes. */
976 BSTR Name; /* the name of this variable */
977 int HelpContext;
978 int HelpStringContext; /* FIXME: where? */
979 BSTR HelpString;
980 int ctCustData;
981 TLBCustData * pCustData;/* linked list to cust data; */
982 struct tagTLBVarDesc * next;
983 } TLBVarDesc;
984
985 /* internal implemented interface data */
986 typedef struct tagTLBImplType
987 {
988 HREFTYPE hRef; /* hRef of interface */
989 int implflags; /* IMPLFLAG_*s */
990 int ctCustData;
991 TLBCustData * pCustData;/* linked list to custom data; */
992 struct tagTLBImplType *next;
993 } TLBImplType;
994
995 /* internal TypeInfo data */
996 typedef struct tagITypeInfoImpl
997 {
998 const ITypeInfo2Vtbl *lpVtbl;
999 const ITypeCompVtbl *lpVtblTypeComp;
1000 LONG ref;
1001 BOOL no_free_data; /* don't free data structures */
1002 TYPEATTR TypeAttr ; /* _lots_ of type information. */
1003 ITypeLibImpl * pTypeLib; /* back pointer to typelib */
1004 int index; /* index in this typelib; */
1005 HREFTYPE hreftype; /* hreftype for app object binding */
1006 /* type libs seem to store the doc strings in ascii
1007 * so why should we do it in unicode?
1008 */
1009 BSTR Name;
1010 BSTR DocString;
1011 BSTR DllName;
1012 unsigned long dwHelpContext;
1013 unsigned long dwHelpStringContext;
1014
1015 /* functions */
1016 TLBFuncDesc * funclist; /* linked list with function descriptions */
1017
1018 /* variables */
1019 TLBVarDesc * varlist; /* linked list with variable descriptions */
1020
1021 /* Implemented Interfaces */
1022 TLBImplType * impltypelist;
1023
1024 int ctCustData;
1025 TLBCustData * pCustData; /* linked list to cust data; */
1026 struct tagITypeInfoImpl * next;
1027 } ITypeInfoImpl;
1028
1029 static inline ITypeInfoImpl *info_impl_from_ITypeComp( ITypeComp *iface )
1030 {
1031 return (ITypeInfoImpl *)((char*)iface - FIELD_OFFSET(ITypeInfoImpl, lpVtblTypeComp));
1032 }
1033
1034 static const ITypeInfo2Vtbl tinfvt;
1035 static const ITypeCompVtbl tcompvt;
1036
1037 static ITypeInfo2 * WINAPI ITypeInfo_Constructor(void);
1038
1039 typedef struct tagTLBContext
1040 {
1041 unsigned int oStart; /* start of TLB in file */
1042 unsigned int pos; /* current pos */
1043 unsigned int length; /* total length */
1044 void *mapping; /* memory mapping */
1045 MSFT_SegDir * pTblDir;
1046 ITypeLibImpl* pLibInfo;
1047 } TLBContext;
1048
1049
1050 static void MSFT_DoRefType(TLBContext *pcx, ITypeLibImpl *pTL, int offset);
1051
1052 /*
1053 debug
1054 */
1055 static void dump_TypeDesc(const TYPEDESC *pTD,char *szVarType) {
1056 if (pTD->vt & VT_RESERVED)
1057 szVarType += strlen(strcpy(szVarType, "reserved | "));
1058 if (pTD->vt & VT_BYREF)
1059 szVarType += strlen(strcpy(szVarType, "ref to "));
1060 if (pTD->vt & VT_ARRAY)
1061 szVarType += strlen(strcpy(szVarType, "array of "));
1062 if (pTD->vt & VT_VECTOR)
1063 szVarType += strlen(strcpy(szVarType, "vector of "));
1064 switch(pTD->vt & VT_TYPEMASK) {
1065 case VT_UI1: sprintf(szVarType, "VT_UI1"); break;
1066 case VT_I2: sprintf(szVarType, "VT_I2"); break;
1067 case VT_I4: sprintf(szVarType, "VT_I4"); break;
1068 case VT_R4: sprintf(szVarType, "VT_R4"); break;
1069 case VT_R8: sprintf(szVarType, "VT_R8"); break;
1070 case VT_BOOL: sprintf(szVarType, "VT_BOOL"); break;
1071 case VT_ERROR: sprintf(szVarType, "VT_ERROR"); break;
1072 case VT_CY: sprintf(szVarType, "VT_CY"); break;
1073 case VT_DATE: sprintf(szVarType, "VT_DATE"); break;
1074 case VT_BSTR: sprintf(szVarType, "VT_BSTR"); break;
1075 case VT_UNKNOWN: sprintf(szVarType, "VT_UNKNOWN"); break;
1076 case VT_DISPATCH: sprintf(szVarType, "VT_DISPATCH"); break;
1077 case VT_I1: sprintf(szVarType, "VT_I1"); break;
1078 case VT_UI2: sprintf(szVarType, "VT_UI2"); break;
1079 case VT_UI4: sprintf(szVarType, "VT_UI4"); break;
1080 case VT_INT: sprintf(szVarType, "VT_INT"); break;
1081 case VT_UINT: sprintf(szVarType, "VT_UINT"); break;
1082 case VT_VARIANT: sprintf(szVarType, "VT_VARIANT"); break;
1083 case VT_VOID: sprintf(szVarType, "VT_VOID"); break;
1084 case VT_HRESULT: sprintf(szVarType, "VT_HRESULT"); break;
1085 case VT_USERDEFINED: sprintf(szVarType, "VT_USERDEFINED ref = %x",
1086 pTD->u.hreftype); break;
1087 case VT_PTR: sprintf(szVarType, "ptr to ");
1088 dump_TypeDesc(pTD->u.lptdesc, szVarType + 7);
1089 break;
1090 case VT_SAFEARRAY: sprintf(szVarType, "safearray of ");
1091 dump_TypeDesc(pTD->u.lptdesc, szVarType + 13);
1092 break;
1093 case VT_CARRAY: sprintf(szVarType, "%d dim array of ",
1094 pTD->u.lpadesc->cDims); /* FIXME print out sizes */
1095 dump_TypeDesc(&pTD->u.lpadesc->tdescElem, szVarType + strlen(szVarType));
1096 break;
1097
1098 default: sprintf(szVarType, "unknown(%d)", pTD->vt & VT_TYPEMASK); break;
1099 }
1100 }
1101
1102 static void dump_ELEMDESC(const ELEMDESC *edesc) {
1103 char buf[200];
1104 USHORT flags = edesc->u.paramdesc.wParamFlags;
1105 dump_TypeDesc(&edesc->tdesc,buf);
1106 MESSAGE("\t\ttdesc.vartype %d (%s)\n",edesc->tdesc.vt,buf);
1107 MESSAGE("\t\tu.paramdesc.wParamFlags");
1108 if (!flags) MESSAGE(" PARAMFLAGS_NONE");
1109 if (flags & PARAMFLAG_FIN) MESSAGE(" PARAMFLAG_FIN");
1110 if (flags & PARAMFLAG_FOUT) MESSAGE(" PARAMFLAG_FOUT");
1111 if (flags & PARAMFLAG_FLCID) MESSAGE(" PARAMFLAG_FLCID");
1112 if (flags & PARAMFLAG_FRETVAL) MESSAGE(" PARAMFLAG_FRETVAL");
1113 if (flags & PARAMFLAG_FOPT) MESSAGE(" PARAMFLAG_FOPT");
1114 if (flags & PARAMFLAG_FHASDEFAULT) MESSAGE(" PARAMFLAG_FHASDEFAULT");
1115 if (flags & PARAMFLAG_FHASCUSTDATA) MESSAGE(" PARAMFLAG_FHASCUSTDATA");
1116 MESSAGE("\n\t\tu.paramdesc.lpex %p\n",edesc->u.paramdesc.pparamdescex);
1117 }
1118 static void dump_FUNCDESC(const FUNCDESC *funcdesc) {
1119 int i;
1120 MESSAGE("memid is %08x\n",funcdesc->memid);
1121 for (i=0;i<funcdesc->cParams;i++) {
1122 MESSAGE("Param %d:\n",i);
1123 dump_ELEMDESC(funcdesc->lprgelemdescParam+i);
1124 }
1125 MESSAGE("\tfunckind: %d (",funcdesc->funckind);
1126 switch (funcdesc->funckind) {
1127 case FUNC_VIRTUAL: MESSAGE("virtual");break;
1128 case FUNC_PUREVIRTUAL: MESSAGE("pure virtual");break;
1129 case FUNC_NONVIRTUAL: MESSAGE("nonvirtual");break;
1130 case FUNC_STATIC: MESSAGE("static");break;
1131 case FUNC_DISPATCH: MESSAGE("dispatch");break;
1132 default: MESSAGE("unknown");break;
1133 }
1134 MESSAGE(")\n\tinvkind: %d (",funcdesc->invkind);
1135 switch (funcdesc->invkind) {
1136 case INVOKE_FUNC: MESSAGE("func");break;
1137 case INVOKE_PROPERTYGET: MESSAGE("property get");break;
1138 case INVOKE_PROPERTYPUT: MESSAGE("property put");break;
1139 case INVOKE_PROPERTYPUTREF: MESSAGE("property put ref");break;
1140 }
1141 MESSAGE(")\n\tcallconv: %d (",funcdesc->callconv);
1142 switch (funcdesc->callconv) {
1143 case CC_CDECL: MESSAGE("cdecl");break;
1144 case CC_PASCAL: MESSAGE("pascal");break;
1145 case CC_STDCALL: MESSAGE("stdcall");break;
1146 case CC_SYSCALL: MESSAGE("syscall");break;
1147 default:break;
1148 }
1149 MESSAGE(")\n\toVft: %d\n", funcdesc->oVft);
1150 MESSAGE("\tcParamsOpt: %d\n", funcdesc->cParamsOpt);
1151 MESSAGE("\twFlags: %x\n", funcdesc->wFuncFlags);
1152
1153 MESSAGE("\telemdescFunc (return value type):\n");
1154 dump_ELEMDESC(&funcdesc->elemdescFunc);
1155 }
1156
1157 static const char * const typekind_desc[] =
1158 {
1159 "TKIND_ENUM",
1160 "TKIND_RECORD",
1161 "TKIND_MODULE",
1162 "TKIND_INTERFACE",
1163 "TKIND_DISPATCH",
1164 "TKIND_COCLASS",
1165 "TKIND_ALIAS",
1166 "TKIND_UNION",
1167 "TKIND_MAX"
1168 };
1169
1170 static void dump_TLBFuncDescOne(const TLBFuncDesc * pfd)
1171 {
1172 int i;
1173 MESSAGE("%s(%u)\n", debugstr_w(pfd->Name), pfd->funcdesc.cParams);
1174 for (i=0;i<pfd->funcdesc.cParams;i++)
1175 MESSAGE("\tparm%d: %s\n",i,debugstr_w(pfd->pParamDesc[i].Name));
1176
1177
1178 dump_FUNCDESC(&(pfd->funcdesc));
1179
1180 MESSAGE("\thelpstring: %s\n", debugstr_w(pfd->HelpString));
1181 MESSAGE("\tentry: %s\n", (pfd->Entry == (void *)-1) ? "invalid" : debugstr_w(pfd->Entry));
1182 }
1183 static void dump_TLBFuncDesc(const TLBFuncDesc * pfd)
1184 {
1185 while (pfd)
1186 {
1187 dump_TLBFuncDescOne(pfd);
1188 pfd = pfd->next;
1189 };
1190 }
1191 static void dump_TLBVarDesc(const TLBVarDesc * pvd)
1192 {
1193 while (pvd)
1194 {
1195 TRACE_(typelib)("%s\n", debugstr_w(pvd->Name));
1196 pvd = pvd->next;
1197 };
1198 }
1199
1200 static void dump_TLBImpLib(const TLBImpLib *import)
1201 {
1202 TRACE_(typelib)("%s %s\n", debugstr_guid(&(import->guid)),
1203 debugstr_w(import->name));
1204 TRACE_(typelib)("v%d.%d lcid=%x offset=%x\n", import->wVersionMajor,
1205 import->wVersionMinor, import->lcid, import->offset);
1206 }
1207
1208 static void dump_TLBRefType(const ITypeLibImpl *pTL)
1209 {
1210 TLBRefType *ref;
1211
1212 LIST_FOR_EACH_ENTRY(ref, &pTL->ref_list, TLBRefType, entry)
1213 {
1214 TRACE_(typelib)("href:0x%08x\n", ref->reference);
1215 if(ref->index == -1)
1216 TRACE_(typelib)("%s\n", debugstr_guid(&(ref->guid)));
1217 else
1218 TRACE_(typelib)("type no: %d\n", ref->index);
1219
1220 if(ref->pImpTLInfo != TLB_REF_INTERNAL && ref->pImpTLInfo != TLB_REF_NOT_FOUND)
1221 {
1222 TRACE_(typelib)("in lib\n");
1223 dump_TLBImpLib(ref->pImpTLInfo);
1224 }
1225 }
1226 }
1227
1228 static void dump_TLBImplType(const TLBImplType * impl)
1229 {
1230 while (impl) {
1231 TRACE_(typelib)(
1232 "implementing/inheriting interface hRef = %x implflags %x\n",
1233 impl->hRef, impl->implflags);
1234 impl = impl->next;
1235 }
1236 }
1237
1238 static void dump_Variant(const VARIANT * pvar)
1239 {
1240 SYSTEMTIME st;
1241
1242 TRACE("%p->{%s%s", pvar, debugstr_VT(pvar), debugstr_VF(pvar));
1243
1244 if (pvar)
1245 {
1246 if (V_ISBYREF(pvar) || V_TYPE(pvar) == VT_UNKNOWN ||
1247 V_TYPE(pvar) == VT_DISPATCH || V_TYPE(pvar) == VT_RECORD)
1248 {
1249 TRACE(",%p", V_BYREF(pvar));
1250 }
1251 else if (V_ISARRAY(pvar) || V_ISVECTOR(pvar))
1252 {
1253 TRACE(",%p", V_ARRAY(pvar));
1254 }
1255 else switch (V_TYPE(pvar))
1256 {
1257 case VT_I1: TRACE(",%d", V_I1(pvar)); break;
1258 case VT_UI1: TRACE(",%d", V_UI1(pvar)); break;
1259 case VT_I2: TRACE(",%d", V_I2(pvar)); break;
1260 case VT_UI2: TRACE(",%d", V_UI2(pvar)); break;
1261 case VT_INT:
1262 case VT_I4: TRACE(",%d", V_I4(pvar)); break;
1263 case VT_UINT:
1264 case VT_UI4: TRACE(",%d", V_UI4(pvar)); break;
1265 case VT_I8: TRACE(",0x%08x,0x%08x", (ULONG)(V_I8(pvar) >> 32),
1266 (ULONG)(V_I8(pvar) & 0xffffffff)); break;
1267 case VT_UI8: TRACE(",0x%08x,0x%08x", (ULONG)(V_UI8(pvar) >> 32),
1268 (ULONG)(V_UI8(pvar) & 0xffffffff)); break;
1269 case VT_R4: TRACE(",%3.3e", V_R4(pvar)); break;
1270 case VT_R8: TRACE(",%3.3e", V_R8(pvar)); break;
1271 case VT_BOOL: TRACE(",%s", V_BOOL(pvar) ? "TRUE" : "FALSE"); break;
1272 case VT_BSTR: TRACE(",%s", debugstr_w(V_BSTR(pvar))); break;
1273 case VT_CY: TRACE(",0x%08x,0x%08x", V_CY(pvar).s.Hi,
1274 V_CY(pvar).s.Lo); break;
1275 case VT_DATE:
1276 if(!VariantTimeToSystemTime(V_DATE(pvar), &st))
1277 TRACE(",<invalid>");
1278 else
1279 TRACE(",%04d/%02d/%02d %02d:%02d:%02d", st.wYear, st.wMonth, st.wDay,
1280 st.wHour, st.wMinute, st.wSecond);
1281 break;
1282 case VT_ERROR:
1283 case VT_VOID:
1284 case VT_USERDEFINED:
1285 case VT_EMPTY:
1286 case VT_NULL: break;
1287 default: TRACE(",?"); break;
1288 }
1289 }
1290 TRACE("}\n");
1291 }
1292
1293 static void dump_DispParms(const DISPPARAMS * pdp)
1294 {
1295 int index;
1296
1297 TRACE("args=%u named args=%u\n", pdp->cArgs, pdp->cNamedArgs);
1298
1299 if (pdp->cNamedArgs && pdp->rgdispidNamedArgs)
1300 {
1301 TRACE("named args:\n");
1302 for (index = 0; index < pdp->cNamedArgs; index++)
1303 TRACE( "\t0x%x\n", pdp->rgdispidNamedArgs[index] );
1304 }
1305
1306 if (pdp->cArgs && pdp->rgvarg)
1307 {
1308 TRACE("args:\n");
1309 for (index = 0; index < pdp->cArgs; index++)
1310 dump_Variant( &pdp->rgvarg[index] );
1311 }
1312 }
1313
1314 static void dump_TypeInfo(const ITypeInfoImpl * pty)
1315 {
1316 TRACE("%p ref=%u\n", pty, pty->ref);
1317 TRACE("%s %s\n", debugstr_w(pty->Name), debugstr_w(pty->DocString));
1318 TRACE("attr:%s\n", debugstr_guid(&(pty->TypeAttr.guid)));
1319 TRACE("kind:%s\n", typekind_desc[pty->TypeAttr.typekind]);
1320 TRACE("fct:%u var:%u impl:%u\n",
1321 pty->TypeAttr.cFuncs, pty->TypeAttr.cVars, pty->TypeAttr.cImplTypes);
1322 TRACE("wTypeFlags: 0x%04x\n", pty->TypeAttr.wTypeFlags);
1323 TRACE("parent tlb:%p index in TLB:%u\n",pty->pTypeLib, pty->index);
1324 if (pty->TypeAttr.typekind == TKIND_MODULE) TRACE("dllname:%s\n", debugstr_w(pty->DllName));
1325 if (TRACE_ON(ole))
1326 dump_TLBFuncDesc(pty->funclist);
1327 dump_TLBVarDesc(pty->varlist);
1328 dump_TLBImplType(pty->impltypelist);
1329 }
1330
1331 static void dump_VARDESC(const VARDESC *v)
1332 {
1333 MESSAGE("memid %d\n",v->memid);
1334 MESSAGE("lpstrSchema %s\n",debugstr_w(v->lpstrSchema));
1335 MESSAGE("oInst %d\n",v->u.oInst);
1336 dump_ELEMDESC(&(v->elemdescVar));
1337 MESSAGE("wVarFlags %x\n",v->wVarFlags);
1338 MESSAGE("varkind %d\n",v->varkind);
1339 }
1340
1341 static TYPEDESC stndTypeDesc[VT_LPWSTR+1]=
1342 {
1343 /* VT_LPWSTR is largest type that */
1344 /* may appear in type description*/
1345 {{0}, 0},{{0}, 1},{{0}, 2},{{0}, 3},{{0}, 4},
1346 {{0}, 5},{{0}, 6},{{0}, 7},{{0}, 8},{{0}, 9},
1347 {{0},10},{{0},11},{{0},12},{{0},13},{{0},14},
1348 {{0},15},{{0},16},{{0},17},{{0},18},{{0},19},
1349 {{0},20},{{0},21},{{0},22},{{0},23},{{0},24},
1350 {{0},25},{{0},26},{{0},27},{{0},28},{{0},29},
1351 {{0},30},{{0},31}
1352 };
1353
1354 static void TLB_abort(void)
1355 {
1356 DebugBreak();
1357 }
1358 static void * TLB_Alloc(unsigned size)
1359 {
1360 void * ret;
1361 if((ret=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size))==NULL){
1362 /* FIXME */
1363 ERR("cannot allocate memory\n");
1364 }
1365 return ret;
1366 }
1367
1368 static void TLB_Free(void * ptr)
1369 {
1370 HeapFree(GetProcessHeap(), 0, ptr);
1371 }
1372
1373 /* returns the size required for a deep copy of a typedesc into a
1374 * flat buffer */
1375 static SIZE_T TLB_SizeTypeDesc( const TYPEDESC *tdesc, BOOL alloc_initial_space )
1376 {
1377 SIZE_T size = 0;
1378
1379 if (alloc_initial_space)
1380 size += sizeof(TYPEDESC);
1381
1382 switch (tdesc->vt)
1383 {
1384 case VT_PTR:
1385 case VT_SAFEARRAY:
1386 size += TLB_SizeTypeDesc(tdesc->u.lptdesc, TRUE);
1387 break;
1388 case VT_CARRAY:
1389 size += FIELD_OFFSET(ARRAYDESC, rgbounds[tdesc->u.lpadesc->cDims]);
1390 size += TLB_SizeTypeDesc(&tdesc->u.lpadesc->tdescElem, FALSE);
1391 break;
1392 }
1393 return size;
1394 }
1395
1396 /* deep copy a typedesc into a flat buffer */
1397 static void *TLB_CopyTypeDesc( TYPEDESC *dest, const TYPEDESC *src, void *buffer )
1398 {
1399 if (!dest)
1400 {
1401 dest = buffer;
1402 buffer = (char *)buffer + sizeof(TYPEDESC);
1403 }
1404
1405 *dest = *src;
1406
1407 switch (src->vt)
1408 {
1409 case VT_PTR:
1410 case VT_SAFEARRAY:
1411 dest->u.lptdesc = buffer;
1412 buffer = TLB_CopyTypeDesc(NULL, src->u.lptdesc, buffer);
1413 break;
1414 case VT_CARRAY:
1415 dest->u.lpadesc = buffer;
1416 memcpy(dest->u.lpadesc, src->u.lpadesc, FIELD_OFFSET(ARRAYDESC, rgbounds[src->u.lpadesc->cDims]));
1417 buffer = (char *)buffer + FIELD_OFFSET(ARRAYDESC, rgbounds[src->u.lpadesc->cDims]);
1418 buffer = TLB_CopyTypeDesc(&dest->u.lpadesc->tdescElem, &src->u.lpadesc->tdescElem, buffer);
1419 break;
1420 }
1421 return buffer;
1422 }
1423
1424 /* free custom data allocated by MSFT_CustData */
1425 static inline void TLB_FreeCustData(TLBCustData *pCustData)
1426 {
1427 TLBCustData *pCustDataNext;
1428 for (; pCustData; pCustData = pCustDataNext)
1429 {
1430 VariantClear(&pCustData->data);
1431
1432 pCustDataNext = pCustData->next;
1433 TLB_Free(pCustData);
1434 }
1435 }
1436
1437 /**********************************************************************
1438 *
1439 * Functions for reading MSFT typelibs (those created by CreateTypeLib2)
1440 */
1441 static inline unsigned int MSFT_Tell(const TLBContext *pcx)
1442 {
1443 return pcx->pos;
1444 }
1445
1446 static inline void MSFT_Seek(TLBContext *pcx, long where)
1447 {
1448 if (where != DO_NOT_SEEK)
1449 {
1450 where += pcx->oStart;
1451 if (where > pcx->length)
1452 {
1453 /* FIXME */
1454 ERR("seek beyond end (%ld/%d)\n", where, pcx->length );
1455 TLB_abort();
1456 }
1457 pcx->pos = where;
1458 }
1459 }
1460
1461 /* read function */
1462 static DWORD MSFT_Read(void *buffer, DWORD count, TLBContext *pcx, long where )
1463 {
1464 TRACE_(typelib)("pos=0x%08x len=0x%08x 0x%08x 0x%08x 0x%08lx\n",
1465 pcx->pos, count, pcx->oStart, pcx->length, where);
1466
1467 MSFT_Seek(pcx, where);
1468 if (pcx->pos + count > pcx->length) count = pcx->length - pcx->pos;
1469 memcpy( buffer, (char *)pcx->mapping + pcx->pos, count );
1470 pcx->pos += count;
1471 return count;
1472 }
1473
1474 static DWORD MSFT_ReadLEDWords(void *buffer, DWORD count, TLBContext *pcx,
1475 long where )
1476 {
1477 DWORD ret;
1478
1479 ret = MSFT_Read(buffer, count, pcx, where);
1480 FromLEDWords(buffer, ret);
1481
1482 return ret;
1483 }
1484
1485 static DWORD MSFT_ReadLEWords(void *buffer, DWORD count, TLBContext *pcx,
1486 long where )
1487 {
1488 DWORD ret;
1489
1490 ret = MSFT_Read(buffer, count, pcx, where);
1491 FromLEWords(buffer, ret);
1492
1493 return ret;
1494 }
1495
1496 static void MSFT_ReadGuid( GUID *pGuid, int offset, TLBContext *pcx)
1497 {
1498 if(offset<0 || pcx->pTblDir->pGuidTab.offset <0){
1499 memset(pGuid,0, sizeof(GUID));
1500 return;
1501 }
1502 MSFT_Read(pGuid, sizeof(GUID), pcx, pcx->pTblDir->pGuidTab.offset+offset );
1503 pGuid->Data1 = FromLEDWord(pGuid->Data1);
1504 pGuid->Data2 = FromLEWord(pGuid->Data2);
1505 pGuid->Data3 = FromLEWord(pGuid->Data3);
1506 TRACE_(typelib)("%s\n", debugstr_guid(pGuid));
1507 }
1508
1509 static HREFTYPE MSFT_ReadHreftype( TLBContext *pcx, int offset )
1510 {
1511 MSFT_NameIntro niName;
1512
1513 if (offset < 0)
1514 {
1515 ERR_(typelib)("bad offset %d\n", offset);
1516 return -1;
1517 }
1518
1519 MSFT_ReadLEDWords(&niName, sizeof(niName), pcx,
1520 pcx->pTblDir->pNametab.offset+offset);
1521
1522 return niName.hreftype;
1523 }
1524
1525 static BSTR MSFT_ReadName( TLBContext *pcx, int offset)
1526 {
1527 char * name;
1528 MSFT_NameIntro niName;
1529 int lengthInChars;
1530 BSTR bstrName = NULL;
1531
1532 if (offset < 0)
1533 {
1534 ERR_(typelib)("bad offset %d\n", offset);
1535 return NULL;
1536 }
1537 MSFT_ReadLEDWords(&niName, sizeof(niName), pcx,
1538 pcx->pTblDir->pNametab.offset+offset);
1539 niName.namelen &= 0xFF; /* FIXME: correct ? */
1540 name=TLB_Alloc((niName.namelen & 0xff) +1);
1541 MSFT_Read(name, (niName.namelen & 0xff), pcx, DO_NOT_SEEK);
1542 name[niName.namelen & 0xff]='\0';
1543
1544 lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
1545 name, -1, NULL, 0);
1546
1547 /* no invalid characters in string */
1548 if (lengthInChars)
1549 {
1550 bstrName = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
1551
1552 /* don't check for invalid character since this has been done previously */
1553 MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, name, -1, bstrName, lengthInChars);
1554 }
1555 TLB_Free(name);
1556
1557 TRACE_(typelib)("%s %d\n", debugstr_w(bstrName), lengthInChars);
1558 return bstrName;
1559 }
1560
1561 static BSTR MSFT_ReadString( TLBContext *pcx, int offset)
1562 {
1563 char * string;
1564 INT16 length;
1565 int lengthInChars;
1566 BSTR bstr = NULL;
1567
1568 if(offset<0) return NULL;
1569 MSFT_ReadLEWords(&length, sizeof(INT16), pcx, pcx->pTblDir->pStringtab.offset+offset);
1570 if(length <= 0) return 0;
1571 string=TLB_Alloc(length +1);
1572 MSFT_Read(string, length, pcx, DO_NOT_SEEK);
1573 string[length]='\0';
1574
1575 lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
1576 string, -1, NULL, 0);
1577
1578 /* no invalid characters in string */
1579 if (lengthInChars)
1580 {
1581 bstr = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
1582
1583 /* don't check for invalid character since this has been done previously */
1584 MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, string, -1, bstr, lengthInChars);
1585 }
1586 TLB_Free(string);
1587
1588 TRACE_(typelib)("%s %d\n", debugstr_w(bstr), lengthInChars);
1589 return bstr;
1590 }
1591 /*
1592 * read a value and fill a VARIANT structure
1593 */
1594 static void MSFT_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
1595 {
1596 int size;
1597
1598 TRACE_(typelib)("\n");
1599
1600 if(offset <0) { /* data are packed in here */
1601 V_VT(pVar) = (offset & 0x7c000000 )>> 26;
1602 V_I4(pVar) = offset & 0x3ffffff;
1603 return;
1604 }
1605 MSFT_ReadLEWords(&(V_VT(pVar)), sizeof(VARTYPE), pcx,
1606 pcx->pTblDir->pCustData.offset + offset );
1607 TRACE_(typelib)("Vartype = %x\n", V_VT(pVar));
1608 switch (V_VT(pVar)){
1609 case VT_EMPTY: /* FIXME: is this right? */
1610 case VT_NULL: /* FIXME: is this right? */
1611 case VT_I2 : /* this should not happen */
1612 case VT_I4 :
1613 case VT_R4 :
1614 case VT_ERROR :
1615 case VT_BOOL :
1616 case VT_I1 :
1617 case VT_UI1 :
1618 case VT_UI2 :
1619 case VT_UI4 :
1620 case VT_INT :
1621 case VT_UINT :
1622 case VT_VOID : /* FIXME: is this right? */
1623 case VT_HRESULT :
1624 size=4; break;
1625 case VT_R8 :
1626 case VT_CY :
1627 case VT_DATE :
1628 case VT_I8 :
1629 case VT_UI8 :
1630 case VT_DECIMAL : /* FIXME: is this right? */
1631 case VT_FILETIME :
1632 size=8;break;
1633 /* pointer types with known behaviour */
1634 case VT_BSTR :{
1635 char * ptr;
1636 MSFT_ReadLEDWords(&size, sizeof(INT), pcx, DO_NOT_SEEK );
1637 if(size < 0) {
1638 char next;
1639 DWORD origPos = MSFT_Tell(pcx), nullPos;
1640
1641 do {
1642 MSFT_Read(&next, 1, pcx, DO_NOT_SEEK);
1643 } while (next);
1644 nullPos = MSFT_Tell(pcx);
1645 size = nullPos - origPos;
1646 MSFT_Seek(pcx, origPos);
1647 }
1648 ptr=TLB_Alloc(size);/* allocate temp buffer */
1649 MSFT_Read(ptr, size, pcx, DO_NOT_SEEK);/* read string (ANSI) */
1650 V_BSTR(pVar)=SysAllocStringLen(NULL,size);
1651 /* FIXME: do we need a AtoW conversion here? */
1652 V_UNION(pVar, bstrVal[size])='\0';
1653 while(size--) V_UNION(pVar, bstrVal[size])=ptr[size];
1654 TLB_Free(ptr);
1655 }
1656 size=-4; break;
1657 /* FIXME: this will not work AT ALL when the variant contains a pointer */
1658 case VT_DISPATCH :
1659 case VT_VARIANT :
1660 case VT_UNKNOWN :
1661 case VT_PTR :
1662 case VT_SAFEARRAY :
1663 case VT_CARRAY :
1664 case VT_USERDEFINED :
1665 case VT_LPSTR :
1666 case VT_LPWSTR :
1667 case VT_BLOB :
1668 case VT_STREAM :
1669 case VT_STORAGE :
1670 case VT_STREAMED_OBJECT :
1671 case VT_STORED_OBJECT :
1672 case VT_BLOB_OBJECT :
1673 case VT_CF :
1674 case VT_CLSID :
1675 default:
1676 size=0;
1677 FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
1678 V_VT(pVar));
1679 }
1680
1681 if(size>0) /* (big|small) endian correct? */
1682 MSFT_Read(&(V_I2(pVar)), size, pcx, DO_NOT_SEEK );
1683 return;
1684 }
1685 /*
1686 * create a linked list with custom data
1687 */
1688 static int MSFT_CustData( TLBContext *pcx, int offset, TLBCustData** ppCustData )
1689 {
1690 MSFT_CDGuid entry;
1691 TLBCustData* pNew;
1692 int count=0;
1693
1694 TRACE_(typelib)("\n");
1695
1696 while(offset >=0){
1697 count++;
1698 pNew=TLB_Alloc(sizeof(TLBCustData));
1699 MSFT_ReadLEDWords(&entry, sizeof(entry), pcx, pcx->pTblDir->pCDGuids.offset+offset);
1700 MSFT_ReadGuid(&(pNew->guid), entry.GuidOffset , pcx);
1701 MSFT_ReadValue(&(pNew->data), entry.DataOffset, pcx);
1702 /* add new custom data at head of the list */
1703 pNew->next=*ppCustData;
1704 *ppCustData=pNew;
1705 offset = entry.next;
1706 }
1707 return count;
1708 }
1709
1710 static void MSFT_GetTdesc(TLBContext *pcx, INT type, TYPEDESC *pTd,
1711 ITypeInfoImpl *pTI)
1712 {
1713 if(type <0)
1714 pTd->vt=type & VT_TYPEMASK;
1715 else
1716 *pTd=pcx->pLibInfo->pTypeDesc[type/(2*sizeof(INT))];
1717
1718 if(pTd->vt == VT_USERDEFINED)
1719 MSFT_DoRefType(pcx, pTI->pTypeLib, pTd->u.hreftype);
1720
1721 TRACE_(typelib)("vt type = %X\n", pTd->vt);
1722 }
1723
1724 static void MSFT_ResolveReferencedTypes(TLBContext *pcx, ITypeInfoImpl *pTI, TYPEDESC *lpTypeDesc)
1725 {
1726 /* resolve referenced type if any */
1727 while (lpTypeDesc)
1728 {
1729 switch (lpTypeDesc->vt)
1730 {
1731 case VT_PTR:
1732 lpTypeDesc = lpTypeDesc->u.lptdesc;
1733 break;
1734
1735 case VT_CARRAY:
1736 lpTypeDesc = & (lpTypeDesc->u.lpadesc->tdescElem);
1737 break;
1738
1739 case VT_USERDEFINED:
1740 MSFT_DoRefType(pcx, pTI->pTypeLib,
1741 lpTypeDesc->u.hreftype);
1742
1743 lpTypeDesc = NULL;
1744 break;
1745
1746 default:
1747 lpTypeDesc = NULL;
1748 }
1749 }
1750 }
1751
1752 static void
1753 MSFT_DoFuncs(TLBContext* pcx,
1754 ITypeInfoImpl* pTI,
1755 int cFuncs,
1756 int cVars,
1757 int offset,
1758 TLBFuncDesc** pptfd)
1759 {
1760 /*
1761 * member information is stored in a data structure at offset
1762 * indicated by the memoffset field of the typeinfo structure
1763 * There are several distinctive parts.
1764 * The first part starts with a field that holds the total length
1765 * of this (first) part excluding this field. Then follow the records,
1766 * for each member there is one record.
1767 *
1768 * The first entry is always the length of the record (including this
1769 * length word).
1770 * The rest of the record depends on the type of the member. If there is
1771 * a field indicating the member type (function, variable, interface, etc)
1772 * I have not found it yet. At this time we depend on the information
1773 * in the type info and the usual order how things are stored.
1774 *
1775 * Second follows an array sized nrMEM*sizeof(INT) with a member id
1776 * for each member;
1777 *
1778 * Third is an equal sized array with file offsets to the name entry
1779 * of each member.
1780 *
1781 * The fourth and last (?) part is an array with offsets to the records
1782 * in the first part of this file segment.
1783 */
1784
1785 int infolen, nameoffset, reclength, nrattributes, i;
1786 int recoffset = offset + sizeof(INT);
1787
1788 char *recbuf = HeapAlloc(GetProcessHeap(), 0, 0xffff);
1789 MSFT_FuncRecord * pFuncRec=(MSFT_FuncRecord *) recbuf;
1790 TLBFuncDesc *ptfd_prev = NULL;
1791
1792 TRACE_(typelib)("\n");
1793
1794 MSFT_ReadLEDWords(&infolen, sizeof(INT), pcx, offset);
1795
1796 for ( i = 0; i < cFuncs ; i++ )
1797 {
1798 *pptfd = TLB_Alloc(sizeof(TLBFuncDesc));
1799
1800 /* name, eventually add to a hash table */
1801 MSFT_ReadLEDWords(&nameoffset, sizeof(INT), pcx,
1802 offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
1803
1804 /* nameoffset is sometimes -1 on the second half of a propget/propput
1805 * pair of functions */
1806 if ((nameoffset == -1) && (i > 0))
1807 (*pptfd)->Name = SysAllocString(ptfd_prev->Name);
1808 else
1809 (*pptfd)->Name = MSFT_ReadName(pcx, nameoffset);
1810
1811 /* read the function information record */
1812 MSFT_ReadLEDWords(&reclength, sizeof(INT), pcx, recoffset);
1813
1814 reclength &= 0xffff;
1815
1816 MSFT_ReadLEDWords(pFuncRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK);
1817
1818 /* do the attributes */
1819 nrattributes = (reclength - pFuncRec->nrargs * 3 * sizeof(int) - 0x18)
1820 / sizeof(int);
1821
1822 if ( nrattributes > 0 )
1823 {
1824 (*pptfd)->helpcontext = pFuncRec->OptAttr[0] ;
1825
1826 if ( nrattributes > 1 )
1827 {
1828 (*pptfd)->HelpString = MSFT_ReadString(pcx,
1829 pFuncRec->OptAttr[1]) ;
1830
1831 if ( nrattributes > 2 )
1832 {
1833 if ( pFuncRec->FKCCIC & 0x2000 )
1834 {
1835 if (HIWORD(pFuncRec->OptAttr[2]) != 0)
1836 ERR("ordinal 0x%08x invalid, HIWORD != 0\n", pFuncRec->OptAttr[2]);
1837 (*pptfd)->Entry = (BSTR)pFuncRec->OptAttr[2];
1838 }
1839 else
1840 {
1841 (*pptfd)->Entry = MSFT_ReadString(pcx,
1842 pFuncRec->OptAttr[2]);
1843 }
1844 if( nrattributes > 5 )
1845 {
1846 (*pptfd)->HelpStringContext = pFuncRec->OptAttr[5] ;
1847
1848 if ( nrattributes > 6 && pFuncRec->FKCCIC & 0x80 )
1849 {
1850 MSFT_CustData(pcx,
1851 pFuncRec->OptAttr[6],
1852 &(*pptfd)->pCustData);
1853 }
1854 }
1855 }
1856 else
1857 {
1858 (*pptfd)->Entry = (BSTR)-1;
1859 }
1860 }
1861 }
1862
1863 /* fill the FuncDesc Structure */
1864 MSFT_ReadLEDWords( & (*pptfd)->funcdesc.memid, sizeof(INT), pcx,
1865 offset + infolen + ( i + 1) * sizeof(INT));
1866
1867 (*pptfd)->funcdesc.funckind = (pFuncRec->FKCCIC) & 0x7;
1868 (*pptfd)->funcdesc.invkind = (pFuncRec->FKCCIC) >> 3 & 0xF;
1869 (*pptfd)->funcdesc.callconv = (pFuncRec->FKCCIC) >> 8 & 0xF;
1870 (*pptfd)->funcdesc.cParams = pFuncRec->nrargs ;
1871 (*pptfd)->funcdesc.cParamsOpt = pFuncRec->nroargs ;
1872 (*pptfd)->funcdesc.oVft = pFuncRec->VtableOffset ;
1873 (*pptfd)->funcdesc.wFuncFlags = LOWORD(pFuncRec->Flags) ;
1874
1875 MSFT_GetTdesc(pcx,
1876 pFuncRec->DataType,
1877 &(*pptfd)->funcdesc.elemdescFunc.tdesc,
1878 pTI);
1879 MSFT_ResolveReferencedTypes(pcx, pTI, &(*pptfd)->funcdesc.elemdescFunc.tdesc);
1880
1881 /* do the parameters/arguments */
1882 if(pFuncRec->nrargs)
1883 {
1884 int j = 0;
1885 MSFT_ParameterInfo paraminfo;
1886
1887 (*pptfd)->funcdesc.lprgelemdescParam =
1888 TLB_Alloc(pFuncRec->nrargs * sizeof(ELEMDESC));
1889
1890 (*pptfd)->pParamDesc =
1891 TLB_Alloc(pFuncRec->nrargs * sizeof(TLBParDesc));
1892
1893 MSFT_ReadLEDWords(&paraminfo, sizeof(paraminfo), pcx,
1894 recoffset + reclength - pFuncRec->nrargs * sizeof(MSFT_ParameterInfo));
1895
1896 for ( j = 0 ; j < pFuncRec->nrargs ; j++ )
1897 {
1898 ELEMDESC *elemdesc = &(*pptfd)->funcdesc.lprgelemdescParam[j];
1899
1900 MSFT_GetTdesc(pcx,
1901 paraminfo.DataType,
1902 &elemdesc->tdesc,
1903 pTI);
1904
1905 elemdesc->u.paramdesc.wParamFlags = paraminfo.Flags;
1906
1907 /* name */
1908 if (paraminfo.oName == -1)
1909 /* this occurs for [propput] or [propget] methods, so
1910 * we should just set the name of the parameter to the
1911 * name of the method. */
1912 (*pptfd)->pParamDesc[j].Name = SysAllocString((*pptfd)->Name);
1913 else
1914 (*pptfd)->pParamDesc[j].Name =
1915 MSFT_ReadName( pcx, paraminfo.oName );
1916 TRACE_(typelib)("param[%d] = %s\n", j, debugstr_w((*pptfd)->pParamDesc[j].Name));
1917
1918 MSFT_ResolveReferencedTypes(pcx, pTI, &elemdesc->tdesc);
1919
1920 /* default value */
1921 if ( (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) &&
1922 (pFuncRec->FKCCIC & 0x1000) )
1923 {
1924 INT* pInt = (INT *)((char *)pFuncRec +
1925 reclength -
1926 (pFuncRec->nrargs * 4 + 1) * sizeof(INT) );
1927
1928 PARAMDESC* pParamDesc = &elemdesc->u.paramdesc;
1929
1930 pParamDesc->pparamdescex = TLB_Alloc(sizeof(PARAMDESCEX));
1931 pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
1932
1933 MSFT_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue),
1934 pInt[j], pcx);
1935 }
1936 else
1937 elemdesc->u.paramdesc.pparamdescex = NULL;
1938 /* custom info */
1939 if ( nrattributes > 7 + j && pFuncRec->FKCCIC & 0x80 )
1940 {
1941 MSFT_CustData(pcx,
1942 pFuncRec->OptAttr[7+j],
1943 &(*pptfd)->pParamDesc[j].pCustData);
1944 }
1945
1946 /* SEEK value = jump to offset,
1947 * from there jump to the end of record,
1948 * go back by (j-1) arguments
1949 */
1950 MSFT_ReadLEDWords( &paraminfo ,
1951 sizeof(MSFT_ParameterInfo), pcx,
1952 recoffset + reclength - ((pFuncRec->nrargs - j - 1)
1953 * sizeof(MSFT_ParameterInfo)));
1954 }
1955 }
1956
1957 /* scode is not used: archaic win16 stuff FIXME: right? */
1958 (*pptfd)->funcdesc.cScodes = 0 ;
1959 (*pptfd)->funcdesc.lprgscode = NULL ;
1960
1961 ptfd_prev = *pptfd;
1962 pptfd = & ((*pptfd)->next);
1963 recoffset += reclength;
1964 }
1965 HeapFree(GetProcessHeap(), 0, recbuf);
1966 }
1967
1968 static void MSFT_DoVars(TLBContext *pcx, ITypeInfoImpl *pTI, int cFuncs,
1969 int cVars, int offset, TLBVarDesc ** pptvd)
1970 {
1971 int infolen, nameoffset, reclength;
1972 char recbuf[256];
1973 MSFT_VarRecord * pVarRec=(MSFT_VarRecord *) recbuf;
1974 int i;
1975 int recoffset;
1976
1977 TRACE_(typelib)("\n");
1978
1979 MSFT_ReadLEDWords(&infolen,sizeof(INT), pcx, offset);
1980 MSFT_ReadLEDWords(&recoffset,sizeof(INT), pcx, offset + infolen +
1981 ((cFuncs+cVars)*2+cFuncs + 1)*sizeof(INT));
1982 recoffset += offset+sizeof(INT);
1983 for(i=0;i<cVars;i++){
1984 *pptvd=TLB_Alloc(sizeof(TLBVarDesc));
1985 /* name, eventually add to a hash table */
1986 MSFT_ReadLEDWords(&nameoffset, sizeof(INT), pcx,
1987 offset + infolen + (2*cFuncs + cVars + i + 1) * sizeof(INT));
1988 (*pptvd)->Name=MSFT_ReadName(pcx, nameoffset);
1989 /* read the variable information record */
1990 MSFT_ReadLEDWords(&reclength, sizeof(INT), pcx, recoffset);
1991 reclength &=0xff;
1992 MSFT_ReadLEDWords(pVarRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK);
1993 /* Optional data */
1994 if(reclength >(6*sizeof(INT)) )
1995 (*pptvd)->HelpContext=pVarRec->HelpContext;
1996 if(reclength >(7*sizeof(INT)) )
1997 (*pptvd)->HelpString = MSFT_ReadString(pcx, pVarRec->oHelpString) ;
1998 if(reclength >(8*sizeof(INT)) )
1999 if(reclength >(9*sizeof(INT)) )
2000 (*pptvd)->HelpStringContext=pVarRec->HelpStringContext;
2001 /* fill the VarDesc Structure */
2002 MSFT_ReadLEDWords(&(*pptvd)->vardesc.memid, sizeof(INT), pcx,
2003 offset + infolen + (cFuncs + i + 1) * sizeof(INT));
2004 (*pptvd)->vardesc.varkind = pVarRec->VarKind;
2005 (*pptvd)->vardesc.wVarFlags = pVarRec->Flags;
2006 MSFT_GetTdesc(pcx, pVarRec->DataType,
2007 &(*pptvd)->vardesc.elemdescVar.tdesc, pTI);
2008 /* (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) FIXME?? */
2009 if(pVarRec->VarKind == VAR_CONST ){
2010 (*pptvd)->vardesc.u.lpvarValue=TLB_Alloc(sizeof(VARIANT));
2011 MSFT_ReadValue((*pptvd)->vardesc.u.lpvarValue,
2012 pVarRec->OffsValue, pcx);
2013 } else
2014 (*pptvd)->vardesc.u.oInst=pVarRec->OffsValue;
2015 MSFT_ResolveReferencedTypes(pcx, pTI, &(*pptvd)->vardesc.elemdescVar.tdesc);
2016 pptvd=&((*pptvd)->next);
2017 recoffset += reclength;
2018 }
2019 }
2020 /* fill in data for a hreftype (offset). When the referenced type is contained
2021 * in the typelib, it's just an (file) offset in the type info base dir.
2022 * If comes from import, it's an offset+1 in the ImpInfo table
2023 * */
2024 static void MSFT_DoRefType(TLBContext *pcx, ITypeLibImpl *pTL,
2025 int offset)
2026 {
2027 TLBRefType *ref;
2028
2029 TRACE_(typelib)("TLB context %p, TLB offset %x\n", pcx, offset);
2030
2031 LIST_FOR_EACH_ENTRY(ref, &pTL->ref_list, TLBRefType, entry)
2032 {
2033 if(ref->reference == offset) return;
2034 }
2035
2036 ref = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ref));
2037 list_add_tail(&pTL->ref_list, &ref->entry);
2038
2039 if(!MSFT_HREFTYPE_INTHISFILE( offset)) {
2040 /* external typelib */
2041 MSFT_ImpInfo impinfo;
2042 TLBImpLib *pImpLib=(pcx->pLibInfo->pImpLibs);
2043
2044 TRACE_(typelib)("offset %x, masked offset %x\n", offset, offset + (offset & 0xfffffffc));
2045
2046 MSFT_ReadLEDWords(&impinfo, sizeof(impinfo), pcx,
2047 pcx->pTblDir->pImpInfo.offset + (offset & 0xfffffffc));
2048 while (pImpLib){ /* search the known offsets of all import libraries */
2049 if(pImpLib->offset==impinfo.oImpFile) break;
2050 pImpLib=pImpLib->next;
2051 }
2052 if(pImpLib){
2053 ref->reference = offset;
2054 ref->pImpTLInfo = pImpLib;
2055 if(impinfo.flags & MSFT_IMPINFO_OFFSET_IS_GUID) {
2056 MSFT_ReadGuid(&ref->guid, impinfo.oGuid, pcx);
2057 TRACE("importing by guid %s\n", debugstr_guid(&ref->guid));
2058 ref->index = TLB_REF_USE_GUID;
2059 } else
2060 ref->index = impinfo.oGuid;
2061 }else{
2062 ERR("Cannot find a reference\n");
2063 ref->reference = -1;
2064 ref->pImpTLInfo = TLB_REF_NOT_FOUND;
2065 }
2066 }else{
2067 /* in this typelib */
2068 ref->index = MSFT_HREFTYPE_INDEX(offset);
2069 ref->reference = offset;
2070 ref->pImpTLInfo = TLB_REF_INTERNAL;
2071 }
2072 }
2073
2074 /* process Implemented Interfaces of a com class */
2075 static void MSFT_DoImplTypes(TLBContext *pcx, ITypeInfoImpl *pTI, int count,
2076 int offset)
2077 {
2078 int i;
2079 MSFT_RefRecord refrec;
2080 TLBImplType **ppImpl = &pTI->impltypelist;
2081
2082 TRACE_(typelib)("\n");
2083
2084 for(i=0;i<count;i++){
2085 if(offset<0) break; /* paranoia */
2086 *ppImpl=TLB_Alloc(sizeof(**ppImpl));
2087 MSFT_ReadLEDWords(&refrec,sizeof(refrec),pcx,offset+pcx->pTblDir->pRefTab.offset);
2088 MSFT_DoRefType(pcx, pTI->pTypeLib, refrec.reftype);
2089 (*ppImpl)->hRef = refrec.reftype;
2090 (*ppImpl)->implflags=refrec.flags;
2091 (*ppImpl)->ctCustData=
2092 MSFT_CustData(pcx, refrec.oCustData, &(*ppImpl)->pCustData);
2093 offset=refrec.onext;
2094 ppImpl=&((*ppImpl)->next);
2095 }
2096 }
2097 /*
2098 * process a typeinfo record
2099 */
2100 static ITypeInfoImpl * MSFT_DoTypeInfo(
2101 TLBContext *pcx,
2102 int count,
2103 ITypeLibImpl * pLibInfo)
2104 {
2105 MSFT_TypeInfoBase tiBase;
2106 ITypeInfoImpl *ptiRet;
2107
2108 TRACE_(typelib)("count=%u\n", count);
2109
2110 ptiRet = (ITypeInfoImpl*) ITypeInfo_Constructor();
2111 MSFT_ReadLEDWords(&tiBase, sizeof(tiBase) ,pcx ,
2112 pcx->pTblDir->pTypeInfoTab.offset+count*sizeof(tiBase));
2113
2114 /* this is where we are coming from */
2115 ptiRet->pTypeLib = pLibInfo;
2116 ptiRet->index=count;
2117 /* fill in the typeattr fields */
2118
2119 MSFT_ReadGuid(&ptiRet->TypeAttr.guid, tiBase.posguid, pcx);
2120 ptiRet->TypeAttr.lcid=pLibInfo->LibAttr.lcid; /* FIXME: correct? */
2121 ptiRet->TypeAttr.lpstrSchema=NULL; /* reserved */
2122 ptiRet->TypeAttr.cbSizeInstance=tiBase.size;
2123 ptiRet->TypeAttr.typekind=tiBase.typekind & 0xF;
2124 ptiRet->TypeAttr.cFuncs=LOWORD(tiBase.cElement);
2125 ptiRet->TypeAttr.cVars=HIWORD(tiBase.cElement);
2126 ptiRet->TypeAttr.cbAlignment=(tiBase.typekind >> 11 )& 0x1F; /* there are more flags there */
2127 ptiRet->TypeAttr.wTypeFlags=tiBase.flags;
2128 ptiRet->TypeAttr.wMajorVerNum=LOWORD(tiBase.version);
2129 ptiRet->TypeAttr.wMinorVerNum=HIWORD(tiBase.version);
2130 ptiRet->TypeAttr.cImplTypes=tiBase.cImplTypes;
2131 ptiRet->TypeAttr.cbSizeVft=tiBase.cbSizeVft; /* FIXME: this is only the non inherited part */
2132 if(ptiRet->TypeAttr.typekind == TKIND_ALIAS)
2133 MSFT_GetTdesc(pcx, tiBase.datatype1,
2134 &ptiRet->TypeAttr.tdescAlias, ptiRet);
2135
2136 /* FIXME: */
2137 /* IDLDESC idldescType; *//* never saw this one != zero */
2138
2139 /* name, eventually add to a hash table */
2140 ptiRet->Name=MSFT_ReadName(pcx, tiBase.NameOffset);
2141 ptiRet->hreftype = MSFT_ReadHreftype(pcx, tiBase.NameOffset);
2142 TRACE_(typelib)("reading %s\n", debugstr_w(ptiRet->Name));
2143 /* help info */
2144 ptiRet->DocString=MSFT_ReadString(pcx, tiBase.docstringoffs);
2145 ptiRet->dwHelpStringContext=tiBase.helpstringcontext;
2146 ptiRet->dwHelpContext=tiBase.helpcontext;
2147
2148 if (ptiRet->TypeAttr.typekind == TKIND_MODULE)
2149 ptiRet->DllName = MSFT_ReadString(pcx, tiBase.datatype1);
2150
2151 /* note: InfoType's Help file and HelpStringDll come from the containing
2152 * library. Further HelpString and Docstring appear to be the same thing :(
2153 */
2154 /* functions */
2155 if(ptiRet->TypeAttr.cFuncs >0 )
2156 MSFT_DoFuncs(pcx, ptiRet, ptiRet->TypeAttr.cFuncs,
2157 ptiRet->TypeAttr.cVars,
2158 tiBase.memoffset, & ptiRet->funclist);
2159 /* variables */
2160 if(ptiRet->TypeAttr.cVars >0 )
2161 MSFT_DoVars(pcx, ptiRet, ptiRet->TypeAttr.cFuncs,
2162 ptiRet->TypeAttr.cVars,
2163 tiBase.memoffset, & ptiRet->varlist);
2164 if(ptiRet->TypeAttr.cImplTypes >0 ) {
2165 switch(ptiRet->TypeAttr.typekind)
2166 {
2167 case TKIND_COCLASS:
2168 MSFT_DoImplTypes(pcx, ptiRet, ptiRet->TypeAttr.cImplTypes ,
2169 tiBase.datatype1);
2170 break;
2171 case TKIND_DISPATCH:
2172 /* This is not -1 when the interface is a non-base dual interface or
2173 when a dispinterface wraps an interface, i.e., the idl 'dispinterface x {interface y;};'.
2174 Note however that GetRefTypeOfImplType(0) always returns a ref to IDispatch and
2175 not this interface.
2176 */
2177
2178 if (tiBase.datatype1 != -1)
2179 {
2180 ptiRet->impltypelist = TLB_Alloc(sizeof(TLBImplType));
2181 ptiRet->impltypelist->hRef = tiBase.datatype1;
2182 MSFT_DoRefType(pcx, pLibInfo, tiBase.datatype1);
2183 }
2184 break;
2185 default:
2186 ptiRet->impltypelist=TLB_Alloc(sizeof(TLBImplType));
2187 MSFT_DoRefType(pcx, pLibInfo, tiBase.datatype1);
2188 ptiRet->impltypelist->hRef = tiBase.datatype1;
2189 break;
2190 }
2191 }
2192 ptiRet->ctCustData=
2193 MSFT_CustData(pcx, tiBase.oCustData, &ptiRet->pCustData);
2194
2195 TRACE_(typelib)("%s guid: %s kind:%s\n",
2196 debugstr_w(ptiRet->Name),
2197 debugstr_guid(&ptiRet->TypeAttr.guid),
2198 typekind_desc[ptiRet->TypeAttr.typekind]);
2199
2200 return ptiRet;
2201 }
2202
2203 /* Because type library parsing has some degree of overhead, and some apps repeatedly load the same
2204 * typelibs over and over, we cache them here. According to MSDN Microsoft have a similar scheme in
2205 * place. This will cause a deliberate memory leak, but generally losing RAM for cycles is an acceptable
2206 * tradeoff here.
2207 */
2208 static ITypeLibImpl *tlb_cache_first;
2209 static CRITICAL_SECTION cache_section;
2210 static CRITICAL_SECTION_DEBUG cache_section_debug =
2211 {
2212 0, 0, &cache_section,
2213 { &cache_section_debug.ProcessLocksList, &cache_section_debug.ProcessLocksList },
2214 0, 0, { (DWORD_PTR)(__FILE__ ": typelib loader cache") }
2215 };
2216 static CRITICAL_SECTION cache_section = { &cache_section_debug, -1, 0, 0, 0, 0 };
2217
2218
2219 typedef struct TLB_PEFile
2220 {
2221 const IUnknownVtbl *lpvtbl;
2222 LONG refs;
2223 HMODULE dll;
2224 HRSRC typelib_resource;
2225 HGLOBAL typelib_global;
2226 LPVOID typelib_base;
2227 } TLB_PEFile;
2228
2229 static HRESULT WINAPI TLB_PEFile_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
2230 {
2231 if (IsEqualIID(riid, &IID_IUnknown))
2232 {
2233 *ppv = iface;
2234 IUnknown_AddRef(iface);
2235 return S_OK;
2236 }
2237 *ppv = NULL;
2238 return E_NOINTERFACE;
2239 }
2240
2241 static ULONG WINAPI TLB_PEFile_AddRef(IUnknown *iface)
2242 {
2243 TLB_PEFile *This = (TLB_PEFile *)iface;
2244 return InterlockedIncrement(&This->refs);
2245 }
2246
2247 static ULONG WINAPI TLB_PEFile_Release(IUnknown *iface)
2248 {
2249 TLB_PEFile *This = (TLB_PEFile *)iface;
2250 ULONG refs = InterlockedDecrement(&This->refs);
2251 if (!refs)
2252 {
2253 if (This->typelib_global)
2254 FreeResource(This->typelib_global);
2255 if (This->dll)
2256 FreeLibrary(This->dll);
2257 HeapFree(GetProcessHeap(), 0, This);
2258 }
2259 return refs;
2260 }
2261
2262 static const IUnknownVtbl TLB_PEFile_Vtable =
2263 {
2264 TLB_PEFile_QueryInterface,
2265 TLB_PEFile_AddRef,
2266 TLB_PEFile_Release
2267 };
2268
2269 static HRESULT TLB_PEFile_Open(LPCWSTR path, INT index, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile)
2270 {
2271 TLB_PEFile *This;
2272
2273 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
2274 if (!This)
2275 return E_OUTOFMEMORY;
2276
2277 This->lpvtbl = &TLB_PEFile_Vtable;
2278 This->refs = 1;
2279 This->dll = NULL;
2280 This->typelib_resource = NULL;
2281 This->typelib_global = NULL;
2282 This->typelib_base = NULL;
2283
2284 This->dll = LoadLibraryExW(path, 0, DONT_RESOLVE_DLL_REFERENCES |
2285 LOAD_LIBRARY_AS_DATAFILE | LOAD_WITH_ALTERED_SEARCH_PATH);
2286
2287 if (This->dll)
2288 {
2289 static const WCHAR TYPELIBW[] = {'T','Y','P','E','L','I','B',0};
2290 This->typelib_resource = FindResourceW(This->dll, MAKEINTRESOURCEW(index), TYPELIBW);
2291 if (This->typelib_resource)
2292 {
2293 This->typelib_global = LoadResource(This->dll, This->typelib_resource);
2294 if (This->typelib_global)
2295 {
2296 This->typelib_base = LockResource(This->typelib_global);
2297
2298 if (This->typelib_base)
2299 {
2300 *pdwTLBLength = SizeofResource(This->dll, This->typelib_resource);
2301 *ppBase = This->typelib_base;
2302 *ppFile = (IUnknown *)&This->lpvtbl;
2303 return S_OK;
2304 }
2305 }
2306 }
2307 }
2308
2309 TLB_PEFile_Release((IUnknown *)&This->lpvtbl);
2310 return TYPE_E_CANTLOADLIBRARY;
2311 }
2312
2313
2314 typedef struct TLB_Mapping
2315 {
2316 const IUnknownVtbl *lpvtbl;
2317 LONG refs;
2318 HANDLE file;
2319 HANDLE mapping;
2320 LPVOID typelib_base;
2321 } TLB_Mapping;
2322
2323 static HRESULT WINAPI TLB_Mapping_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
2324 {
2325 if (IsEqualIID(riid, &IID_IUnknown))
2326 {
2327 *ppv = iface;
2328 IUnknown_AddRef(iface);
2329 return S_OK;
2330 }
2331 *ppv = NULL;
2332 return E_NOINTERFACE;
2333 }
2334
2335 static ULONG WINAPI TLB_Mapping_AddRef(IUnknown *iface)
2336 {
2337 TLB_Mapping *This = (TLB_Mapping *)iface;
2338 return InterlockedIncrement(&This->refs);
2339 }
2340
2341 static ULONG WINAPI TLB_Mapping_Release(IUnknown *iface)
2342 {
2343 TLB_Mapping *This = (TLB_Mapping *)iface;
2344 ULONG refs = InterlockedDecrement(&This->refs);
2345 if (!refs)
2346 {
2347 if (This->typelib_base)
2348 UnmapViewOfFile(This->typelib_base);
2349 if (This->mapping)
2350 CloseHandle(This->mapping);
2351 if (This->file != INVALID_HANDLE_VALUE)
2352 CloseHandle(This->file);
2353 HeapFree(GetProcessHeap(), 0, This);
2354 }
2355 return refs;
2356 }
2357
2358 static const IUnknownVtbl TLB_Mapping_Vtable =
2359 {
2360 TLB_Mapping_QueryInterface,
2361 TLB_Mapping_AddRef,
2362 TLB_Mapping_Release
2363 };
2364
2365 static HRESULT TLB_Mapping_Open(LPCWSTR path, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile)
2366 {
2367 TLB_Mapping *This;
2368
2369 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
2370 if (!This)
2371 return E_OUTOFMEMORY;
2372
2373 This->lpvtbl = &TLB_Mapping_Vtable;
2374 This->refs = 1;
2375 This->file = INVALID_HANDLE_VALUE;
2376 This->mapping = NULL;
2377 This->typelib_base = NULL;
2378
2379 This->file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2380 if (INVALID_HANDLE_VALUE != This->file)
2381 {
2382 This->mapping = CreateFileMappingW(This->file, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
2383 if (This->mapping)
2384 {
2385 This->typelib_base = MapViewOfFile(This->mapping, FILE_MAP_READ, 0, 0, 0);
2386 if(This->typelib_base)
2387 {
2388 /* retrieve file size */
2389 *pdwTLBLength = GetFileSize(This->file, NULL);
2390 *ppBase = This->typelib_base;
2391 *ppFile = (IUnknown *)&This->lpvtbl;
2392 return S_OK;
2393 }
2394 }
2395 }
2396
2397 IUnknown_Release((IUnknown *)&This->lpvtbl);
2398 return TYPE_E_CANTLOADLIBRARY;
2399 }
2400
2401 /****************************************************************************
2402 * TLB_ReadTypeLib
2403 *
2404 * find the type of the typelib file and map the typelib resource into
2405 * the memory
2406 */
2407 #define MSFT_SIGNATURE 0x5446534D /* "MSFT" */
2408 #define SLTG_SIGNATURE 0x47544c53 /* "SLTG" */
2409 static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath, ITypeLib2 **ppTypeLib)
2410 {
2411 ITypeLibImpl *entry;
2412 HRESULT ret;
2413 INT index = 1;
2414 LPWSTR index_str, file = (LPWSTR)pszFileName;
2415 LPVOID pBase = NULL;
2416 DWORD dwTLBLength = 0;
2417 IUnknown *pFile = NULL;
2418
2419 *ppTypeLib = NULL;
2420
2421 index_str = strrchrW(pszFileName, '\\');
2422 if(index_str && *++index_str != '\0')
2423 {
2424 LPWSTR end_ptr;
2425 long idx = strtolW(index_str, &end_ptr, 10);
2426 if(*end_ptr == '\0')
2427 {
2428 int str_len = index_str - pszFileName - 1;
2429 index = idx;
2430 file = HeapAlloc(GetProcessHeap(), 0, (str_len + 1) * sizeof(WCHAR));
2431 memcpy(file, pszFileName, str_len * sizeof(WCHAR));
2432 file[str_len] = 0;
2433 }
2434 }
2435
2436 if(!SearchPathW(NULL, file, NULL, cchPath, pszPath, NULL))
2437 {
2438 if(strchrW(file, '\\'))
2439 {
2440 lstrcpyW(pszPath, file);
2441 }
2442 else
2443 {
2444 int len = GetSystemDirectoryW(pszPath, cchPath);
2445 pszPath[len] = '\\';
2446 memcpy(pszPath + len + 1, file, (strlenW(file) + 1) * sizeof(WCHAR));
2447 }
2448 }
2449
2450 if(file != pszFileName) HeapFree(GetProcessHeap(), 0, file);
2451
2452 TRACE_(typelib)("File %s index %d\n", debugstr_w(pszPath), index);
2453
2454 /* We look the path up in the typelib cache. If found, we just addref it, and return the pointer. */
2455 EnterCriticalSection(&cache_section);
2456 for (entry = tlb_cache_first; entry != NULL; entry = entry->next)
2457 {
2458 if (!strcmpiW(entry->path, pszPath) && entry->index == index)
2459 {
2460 TRACE("cache hit\n");
2461 *ppTypeLib = (ITypeLib2*)entry;
2462 ITypeLib_AddRef(*ppTypeLib);
2463 LeaveCriticalSection(&cache_section);
2464 return S_OK;
2465 }
2466 }
2467 LeaveCriticalSection(&cache_section);
2468
2469 /* now actually load and parse the typelib */
2470
2471 ret = TLB_PEFile_Open(pszPath, index, &pBase, &dwTLBLength, &pFile);
2472 if (ret == TYPE_E_CANTLOADLIBRARY)
2473 ret = TLB_Mapping_Open(pszPath, &pBase, &dwTLBLength, &pFile);
2474 if (SUCCEEDED(ret))
2475 {
2476 if (dwTLBLength >= 4)
2477 {
2478 DWORD dwSignature = FromLEDWord(*((DWORD*) pBase));
2479 if (dwSignature == MSFT_SIGNATURE)
2480 *ppTypeLib = ITypeLib2_Constructor_MSFT(pBase, dwTLBLength);
2481 else if (dwSignature == SLTG_SIGNATURE)
2482 *ppTypeLib = ITypeLib2_Constructor_SLTG(pBase, dwTLBLength);
2483 else
2484 {
2485 FIXME("Header type magic 0x%08x not supported.\n",dwSignature);
2486 ret = TYPE_E_CANTLOADLIBRARY;
2487 }
2488 }
2489 else
2490 ret = TYPE_E_CANTLOADLIBRARY;
2491 IUnknown_Release(pFile);
2492 }
2493
2494 if(*ppTypeLib) {
2495 ITypeLibImpl *impl = (ITypeLibImpl*)*ppTypeLib;
2496
2497 TRACE("adding to cache\n");
2498 impl->path = HeapAlloc(GetProcessHeap(), 0, (strlenW(pszPath)+1) * sizeof(WCHAR));
2499 lstrcpyW(impl->path, pszPath);
2500 /* We should really canonicalise the path here. */
2501 impl->index = index;
2502
2503 /* FIXME: check if it has added already in the meantime */
2504 EnterCriticalSection(&cache_section);
2505 if ((impl->next = tlb_cache_first) != NULL) impl->next->prev = impl;
2506 impl->prev = NULL;
2507 tlb_cache_first = impl;
2508 LeaveCriticalSection(&cache_section);
2509 ret = S_OK;
2510 } else
2511 ERR("Loading of typelib %s failed with error %d\n", debugstr_w(pszFileName), GetLastError());
2512
2513 return ret;
2514 }
2515
2516 /*================== ITypeLib(2) Methods ===================================*/
2517
2518 static ITypeLibImpl* TypeLibImpl_Constructor(void)
2519 {
2520 ITypeLibImpl* pTypeLibImpl;
2521
2522 pTypeLibImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeLibImpl));
2523 if (!pTypeLibImpl) return NULL;
2524
2525 pTypeLibImpl->lpVtbl = &tlbvt;
2526 pTypeLibImpl->lpVtblTypeComp = &tlbtcvt;
2527 pTypeLibImpl->ref = 1;
2528
2529 list_init(&pTypeLibImpl->ref_list);
2530 pTypeLibImpl->dispatch_href = -1;
2531
2532 return pTypeLibImpl;
2533 }
2534
2535 /****************************************************************************
2536 * ITypeLib2_Constructor_MSFT
2537 *
2538 * loading an MSFT typelib from an in-memory image
2539 */
2540 static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
2541 {
2542 TLBContext cx;
2543 long lPSegDir;
2544 MSFT_Header tlbHeader;
2545 MSFT_SegDir tlbSegDir;
2546 ITypeLibImpl * pTypeLibImpl;
2547
2548 TRACE("%p, TLB length = %d\n", pLib, dwTLBLength);
2549
2550 pTypeLibImpl = TypeLibImpl_Constructor();
2551 if (!pTypeLibImpl) return NULL;
2552
2553 /* get pointer to beginning of typelib data */
2554 cx.pos = 0;
2555 cx.oStart=0;
2556 cx.mapping = pLib;
2557 cx.pLibInfo = pTypeLibImpl;
2558 cx.length = dwTLBLength;
2559
2560 /* read header */
2561 MSFT_ReadLEDWords((void*)&tlbHeader, sizeof(tlbHeader), &cx, 0);
2562 TRACE_(typelib)("header:\n");
2563 TRACE_(typelib)("\tmagic1=0x%08x ,magic2=0x%08x\n",tlbHeader.magic1,tlbHeader.magic2 );
2564 if (tlbHeader.magic1 != MSFT_SIGNATURE) {
2565 FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
2566 return NULL;
2567 }
2568 TRACE_(typelib)("\tdispatchpos = 0x%x\n", tlbHeader.dispatchpos);
2569
2570 /* there is a small amount of information here until the next important
2571 * part:
2572 * the segment directory . Try to calculate the amount of data */
2573 lPSegDir = sizeof(tlbHeader) + (tlbHeader.nrtypeinfos)*4 + ((tlbHeader.varflags & HELPDLLFLAG)? 4 :0);
2574
2575 /* now read the segment directory */
2576 TRACE("read segment directory (at %ld)\n",lPSegDir);
2577 MSFT_ReadLEDWords(&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);
2578 cx.pTblDir = &tlbSegDir;
2579
2580 /* just check two entries */
2581 if ( tlbSegDir.pTypeInfoTab.res0c != 0x0F || tlbSegDir.pImpInfo.res0c != 0x0F)
2582 {
2583 ERR("cannot find the table directory, ptr=0x%lx\n",lPSegDir);
2584 HeapFree(GetProcessHeap(),0,pTypeLibImpl);
2585 return NULL;
2586 }
2587
2588 /* now fill our internal data */
2589 /* TLIBATTR fields */
2590 MSFT_ReadGuid(&pTypeLibImpl->LibAttr.guid, tlbHeader.posguid, &cx);
2591
2592 /* pTypeLibImpl->LibAttr.lcid = tlbHeader.lcid;*/
2593 /* Windows seems to have zero here, is this correct? */
2594 if(SUBLANGID(tlbHeader.lcid) == SUBLANG_NEUTRAL)
2595 pTypeLibImpl->LibAttr.lcid = MAKELCID(MAKELANGID(PRIMARYLANGID(tlbHeader.lcid),0),0);
2596 else
2597 pTypeLibImpl->LibAttr.lcid = 0;
2598
2599 pTypeLibImpl->LibAttr.syskind = tlbHeader.varflags & 0x0f; /* check the mask */
2600 pTypeLibImpl->LibAttr.wMajorVerNum = LOWORD(tlbHeader.version);
2601 pTypeLibImpl->LibAttr.wMinorVerNum = HIWORD(tlbHeader.version);
2602 pTypeLibImpl->LibAttr.wLibFlags = (WORD) tlbHeader.flags & 0xffff;/* check mask */
2603
2604 /* name, eventually add to a hash table */
2605 pTypeLibImpl->Name = MSFT_ReadName(&cx, tlbHeader.NameOffset);
2606
2607 /* help info */
2608 pTypeLibImpl->DocString = MSFT_ReadString(&cx, tlbHeader.helpstring);
2609 pTypeLibImpl->HelpFile = MSFT_ReadString(&cx, tlbHeader.helpfile);
2610
2611 if( tlbHeader.varflags & HELPDLLFLAG)
2612 {
2613 int offset;
2614 MSFT_ReadLEDWords(&offset, sizeof(offset), &cx, sizeof(tlbHeader));
2615 pTypeLibImpl->HelpStringDll = MSFT_ReadString(&cx, offset);
2616 }
2617
2618 pTypeLibImpl->dwHelpContext = tlbHeader.helpstringcontext;
2619
2620 /* custom data */
2621 if(tlbHeader.CustomDataOffset >= 0)
2622 {
2623 pTypeLibImpl->ctCustData = MSFT_CustData(&cx, tlbHeader.CustomDataOffset, &pTypeLibImpl->pCustData);
2624 }
2625
2626 /* fill in type descriptions */
2627 if(tlbSegDir.pTypdescTab.length > 0)
2628 {
2629 int i, j, cTD = tlbSegDir.pTypdescTab.length / (2*sizeof(INT));
2630 INT16 td[4];
2631 pTypeLibImpl->ctTypeDesc = cTD;
2632 pTypeLibImpl->pTypeDesc = TLB_Alloc( cTD * sizeof(TYPEDESC));
2633 MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
2634 for(i=0; i<cTD; )
2635 {
2636 /* FIXME: add several sanity checks here */
2637 pTypeLibImpl->pTypeDesc[i].vt = td[0] & VT_TYPEMASK;
2638 if(td[0] == VT_PTR || td[0] == VT_SAFEARRAY)
2639 {
2640 /* FIXME: check safearray */
2641 if(td[3] < 0)
2642 pTypeLibImpl->pTypeDesc[i].u.lptdesc= & stndTypeDesc[td[2]];
2643 else
2644 pTypeLibImpl->pTypeDesc[i].u.lptdesc= & pTypeLibImpl->pTypeDesc[td[2]/8];
2645 }
2646 else if(td[0] == VT_CARRAY)
2647 {
2648 /* array descr table here */
2649 pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)((int) td[2]); /* temp store offset in*/
2650 }
2651 else if(td[0] == VT_USERDEFINED)
2652 {
2653 pTypeLibImpl->pTypeDesc[i].u.hreftype = MAKELONG(td[2],td[3]);
2654 }
2655 if(++i<cTD) MSFT_ReadLEWords(td, sizeof(td), &cx, DO_NOT_SEEK);
2656 }
2657
2658 /* second time around to fill the array subscript info */
2659 for(i=0;i<cTD;i++)
2660 {
2661 if(pTypeLibImpl->pTypeDesc[i].vt != VT_CARRAY) continue;
2662 if(tlbSegDir.pArrayDescriptions.offset>0)
2663 {
2664 MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) pTypeLibImpl->pTypeDesc[i].u.lpadesc);
2665 pTypeLibImpl->pTypeDesc[i].u.lpadesc = TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
2666
2667 if(td[1]<0)
2668 pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem.vt = td[0] & VT_TYPEMASK;
2669 else
2670 pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem = stndTypeDesc[td[0]/8];
2671
2672 pTypeLibImpl->pTypeDesc[i].u.lpadesc->cDims = td[2];
2673
2674 for(j = 0; j<td[2]; j++)
2675 {
2676 MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements,
2677 sizeof(INT), &cx, DO_NOT_SEEK);
2678 MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound,
2679 sizeof(INT), &cx, DO_NOT_SEEK);
2680 }
2681 }
2682 else
2683 {
2684 pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL;
2685 ERR("didn't find array description data\n");
2686 }
2687 }
2688 }
2689
2690 /* imported type libs */
2691 if(tlbSegDir.pImpFiles.offset>0)
2692 {
2693 TLBImpLib **ppImpLib = &(pTypeLibImpl->pImpLibs);
2694 int oGuid, offset = tlbSegDir.pImpFiles.offset;
2695 UINT16 size;
2696
2697 while(offset < tlbSegDir.pImpFiles.offset +tlbSegDir.pImpFiles.length)
2698 {
2699 char *name;
2700 DWORD len;
2701
2702 *ppImpLib = TLB_Alloc(sizeof(TLBImpLib));
2703 (*ppImpLib)->offset = offset - tlbSegDir.pImpFiles.offset;
2704 MSFT_ReadLEDWords(&oGuid, sizeof(INT), &cx, offset);
2705
2706 MSFT_ReadLEDWords(&(*ppImpLib)->lcid, sizeof(LCID), &cx, DO_NOT_SEEK);
2707 MSFT_ReadLEWords(&(*ppImpLib)->wVersionMajor, sizeof(WORD), &cx, DO_NOT_SEEK);
2708 MSFT_ReadLEWords(&(*ppImpLib)->wVersionMinor, sizeof(WORD), &cx, DO_NOT_SEEK);
2709 MSFT_ReadLEWords(& size, sizeof(UINT16), &cx, DO_NOT_SEEK);
2710
2711 size >>= 2;
2712 name = TLB_Alloc(size+1);
2713 MSFT_Read(name, size, &cx, DO_NOT_SEEK);
2714 len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0 );
2715 (*ppImpLib)->name = TLB_Alloc(len * sizeof(WCHAR));
2716 MultiByteToWideChar(CP_ACP, 0, name, -1, (*ppImpLib)->name, len );
2717 TLB_Free(name);
2718
2719 MSFT_ReadGuid(&(*ppImpLib)->guid, oGuid, &cx);
2720 offset = (offset + sizeof(INT) + sizeof(DWORD) + sizeof(LCID) + sizeof(UINT16) + size + 3) & ~3;
2721
2722 ppImpLib = &(*ppImpLib)->next;
2723 }
2724 }
2725
2726 pTypeLibImpl->dispatch_href = tlbHeader.dispatchpos;
2727 if(pTypeLibImpl->dispatch_href != -1)
2728 MSFT_DoRefType(&cx, pTypeLibImpl, pTypeLibImpl->dispatch_href);
2729
2730 /* type info's */
2731 if(tlbHeader.nrtypeinfos >= 0 )
2732 {
2733 /*pTypeLibImpl->TypeInfoCount=tlbHeader.nrtypeinfos; */
2734 ITypeInfoImpl **ppTI = &(pTypeLibImpl->pTypeInfo);
2735 int i;
2736
2737 for(i = 0; i < tlbHeader.nrtypeinfos; i++)
2738 {
2739 *ppTI = MSFT_DoTypeInfo(&cx, i, pTypeLibImpl);
2740
2741 ppTI = &((*ppTI)->next);
2742 (pTypeLibImpl->TypeInfoCount)++;
2743 }
2744 }
2745
2746 TRACE("(%p)\n", pTypeLibImpl);
2747 return (ITypeLib2*) pTypeLibImpl;
2748 }
2749
2750
2751 static BSTR TLB_MultiByteToBSTR(const char *ptr)
2752 {
2753 DWORD len;
2754 WCHAR *nameW;
2755 BSTR ret;
2756
2757 len = MultiByteToWideChar(CP_ACP, 0, ptr, -1, NULL, 0);
2758 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2759 MultiByteToWideChar(CP_ACP, 0, ptr, -1, nameW, len);
2760 ret = SysAllocString(nameW);
2761 HeapFree(GetProcessHeap(), 0, nameW);
2762 return ret;
2763 }
2764
2765 static BOOL TLB_GUIDFromString(const char *str, GUID *guid)
2766 {
2767 char b[3];
2768 int i;
2769 short s;
2770
2771 if(sscanf(str, "%x-%hx-%hx-%hx", &guid->Data1, &guid->Data2, &guid->Data3, &s) != 4) {
2772 FIXME("Can't parse guid %s\n", debugstr_guid(guid));
2773 return FALSE;
2774 }
2775
2776 guid->Data4[0] = s >> 8;
2777 guid->Data4[1] = s & 0xff;
2778
2779 b[2] = '\0';
2780 for(i = 0; i < 6; i++) {
2781 memcpy(b, str + 24 + 2 * i, 2);
2782 guid->Data4[i + 2] = strtol(b, NULL, 16);
2783 }
2784 return TRUE;
2785 }
2786
2787 static WORD SLTG_ReadString(const char *ptr, BSTR *pBstr)
2788 {
2789 WORD bytelen;
2790 DWORD len;
2791 WCHAR *nameW;
2792
2793 *pBstr = NULL;
2794 bytelen = *(const WORD*)ptr;
2795 if(bytelen == 0xffff) return 2;
2796 len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, NULL, 0);
2797 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2798 len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, nameW, len);
2799 *pBstr = SysAllocStringLen(nameW, len);
2800 HeapFree(GetProcessHeap(), 0, nameW);
2801 return bytelen + 2;
2802 }
2803
2804 static WORD SLTG_ReadStringA(const char *ptr, char **str)
2805 {
2806 WORD bytelen;
2807
2808 *str = NULL;
2809 bytelen = *(const WORD*)ptr;
2810 if(bytelen == 0xffff) return 2;
2811 *str = HeapAlloc(GetProcessHeap(), 0, bytelen + 1);
2812 memcpy(*str, ptr + 2, bytelen);
2813 (*str)[bytelen] = '\0';
2814 return bytelen + 2;
2815 }
2816
2817 static DWORD SLTG_ReadLibBlk(LPVOID pLibBlk, ITypeLibImpl *pTypeLibImpl)
2818 {
2819 char *ptr = pLibBlk;
2820 WORD w;
2821
2822 if((w = *(WORD*)ptr) != SLTG_LIBBLK_MAGIC) {
2823 FIXME("libblk magic = %04x\n", w);
2824 return 0;
2825 }
2826
2827 ptr += 6;
2828 if((w = *(WORD*)ptr) != 0xffff) {
2829 FIXME("LibBlk.res06 = %04x. Assumung string and skipping\n", w);
2830 ptr += w;
2831 }
2832 ptr += 2;
2833
2834 ptr += SLTG_ReadString(ptr, &pTypeLibImpl->DocString);
2835
2836 ptr += SLTG_ReadString(ptr, &pTypeLibImpl->HelpFile);
2837
2838 pTypeLibImpl->dwHelpContext = *(DWORD*)ptr;
2839 ptr += 4;
2840
2841 pTypeLibImpl->LibAttr.syskind = *(WORD*)ptr;
2842 ptr += 2;
2843
2844 if(SUBLANGID(*(WORD*)ptr) == SUBLANG_NEUTRAL)
2845 pTypeLibImpl->LibAttr.lcid = MAKELCID(MAKELANGID(PRIMARYLANGID(*(WORD*)ptr),0),0);
2846 else
2847 pTypeLibImpl->LibAttr.lcid = 0;
2848 ptr += 2;
2849
2850 ptr += 4; /* skip res12 */
2851
2852 pTypeLibImpl->LibAttr.wLibFlags = *(WORD*)ptr;
2853 ptr += 2;
2854
2855 pTypeLibImpl->LibAttr.wMajorVerNum = *(WORD*)ptr;
2856 ptr += 2;
2857
2858 pTypeLibImpl->LibAttr.wMinorVerNum = *(WORD*)ptr;
2859 ptr += 2;
2860
2861 memcpy(&pTypeLibImpl->LibAttr.guid, ptr, sizeof(GUID));
2862 ptr += sizeof(GUID);
2863
2864 return ptr - (char*)pLibBlk;
2865 }
2866
2867 /* stores a mapping between the sltg typeinfo's references and the typelib's HREFTYPEs */
2868 typedef struct
2869 {
2870 unsigned int num;
2871 HREFTYPE refs[1];
2872 } sltg_ref_lookup_t;
2873
2874 static HRESULT sltg_get_typelib_ref(const sltg_ref_lookup_t *table, DWORD typeinfo_ref,
2875 HREFTYPE *typelib_ref)
2876 {
2877 if(typeinfo_ref < table->num)
2878 {
2879 *typelib_ref = table->refs[typeinfo_ref];
2880 return S_OK;
2881 }
2882
2883 ERR("Unable to find reference\n");
2884 *typelib_ref = -1;
2885 return E_FAIL;
2886 }
2887
2888 static WORD *SLTG_DoType(WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_lookup_t *ref_lookup)
2889 {
2890 BOOL done = FALSE;
2891
2892 while(!done) {
2893 if((*pType & 0xe00) == 0xe00) {
2894 pTD->vt = VT_PTR;
2895 pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2896 sizeof(TYPEDESC));
2897 pTD = pTD->u.lptdesc;
2898 }
2899 switch(*pType & 0x3f) {
2900 case VT_PTR:
2901 pTD->vt = VT_PTR;
2902 pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2903 sizeof(TYPEDESC));
2904 pTD = pTD->u.lptdesc;
2905 break;
2906
2907 case VT_USERDEFINED:
2908 pTD->vt = VT_USERDEFINED;
2909 sltg_get_typelib_ref(ref_lookup, *(++pType) / 4, &pTD->u.hreftype);
2910 done = TRUE;
2911 break;
2912
2913 case VT_CARRAY:
2914 {
2915 /* *(pType+1) is offset to a SAFEARRAY, *(pType+2) is type of
2916 array */
2917
2918 SAFEARRAY *pSA = (SAFEARRAY *)(pBlk + *(++pType));
2919
2920 pTD->vt = VT_CARRAY;
2921 pTD->u.lpadesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2922 sizeof(ARRAYDESC) +
2923 (pSA->cDims - 1) * sizeof(SAFEARRAYBOUND));
2924 pTD->u.lpadesc->cDims = pSA->cDims;
2925 memcpy(pTD->u.lpadesc->rgbounds, pSA->rgsabound,
2926 pSA->cDims * sizeof(SAFEARRAYBOUND));
2927
2928 pTD = &pTD->u.lpadesc->tdescElem;
2929 break;
2930 }
2931
2932 case VT_SAFEARRAY:
2933 {
2934 /* FIXME: *(pType+1) gives an offset to SAFEARRAY, is this
2935 useful? */
2936
2937 pType++;
2938 pTD->vt = VT_SAFEARRAY;
2939 pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2940 sizeof(TYPEDESC));
2941 pTD = pTD->u.lptdesc;
2942 break;
2943 }
2944 default:
2945 pTD->vt = *pType & 0x3f;
2946 done = TRUE;
2947 break;
2948 }
2949 pType++;
2950 }
2951 return pType;
2952 }
2953
2954 static WORD *SLTG_DoElem(WORD *pType, char *pBlk,
2955 ELEMDESC *pElem, const sltg_ref_lookup_t *ref_lookup)
2956 {
2957 /* Handle [in/out] first */
2958 if((*pType & 0xc000) == 0xc000)
2959 pElem->u.paramdesc.wParamFlags = PARAMFLAG_NONE;
2960 else if(*pType & 0x8000)
2961 pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FOUT;
2962 else if(*pType & 0x4000)
2963 pElem->u.paramdesc.wParamFlags = PARAMFLAG_FOUT;
2964 else
2965 pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN;
2966
2967 if(*pType & 0x2000)
2968 pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FLCID;
2969
2970 if(*pType & 0x80)
2971 pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FRETVAL;
2972
2973 return SLTG_DoType(pType, pBlk, &pElem->tdesc, ref_lookup);
2974 }
2975
2976
2977 static sltg_ref_lookup_t *SLTG_DoRefs(SLTG_RefInfo *pRef, ITypeLibImpl *pTL,
2978 char *pNameTable)
2979 {
2980 int ref;
2981 char *name;
2982 TLBRefType *ref_type;
2983 sltg_ref_lookup_t *table;
2984 HREFTYPE typelib_ref;
2985
2986 if(pRef->magic != SLTG_REF_MAGIC) {
2987 FIXME("Ref magic = %x\n", pRef->magic);
2988 return NULL;
2989 }
2990 name = ( (char*)(&pRef->names) + pRef->number);
2991
2992 table = HeapAlloc(GetProcessHeap(), 0, sizeof(*table) + ((pRef->number >> 3) - 1) * sizeof(table->refs[0]));
2993 table->num = pRef->number >> 3;
2994
2995 /* FIXME should scan the existing list and reuse matching refs added by previous typeinfos */
2996
2997 /* We don't want the first href to be 0 */
2998 typelib_ref = (list_count(&pTL->ref_list) + 1) << 2;
2999
3000 for(ref = 0; ref < pRef->number >> 3; ref++) {
3001 char *refname;
3002 unsigned int lib_offs, type_num;
3003
3004 ref_type = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ref_type));
3005
3006 name += SLTG_ReadStringA(name, &refname);
3007 if(sscanf(refname, "*\\R%x*#%x", &lib_offs, &type_num) != 2)
3008 FIXME("Can't sscanf ref\n");
3009 if(lib_offs != 0xffff) {
3010 TLBImpLib **import = &pTL->pImpLibs;
3011
3012 while(*import) {
3013 if((*import)->offset == lib_offs)
3014 break;
3015 import = &(*import)->next;
3016 }
3017 if(!*import) {
3018 char fname[MAX_PATH+1];
3019 int len;
3020
3021 *import = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3022 sizeof(**import));
3023 (*import)->offset = lib_offs;
3024 TLB_GUIDFromString( pNameTable + lib_offs + 4,
3025 &(*import)->guid);
3026 if(sscanf(pNameTable + lib_offs + 40, "}#%hd.%hd#%x#%s",
3027 &(*import)->wVersionMajor,
3028 &(*import)->wVersionMinor,
3029 &(*import)->lcid, fname) != 4) {
3030 FIXME("can't sscanf ref %s\n",
3031 pNameTable + lib_offs + 40);
3032 }
3033 len = strlen(fname);
3034 if(fname[len-1] != '#')
3035 FIXME("fname = %s\n", fname);
3036 fname[len-1] = '\0';
3037 (*import)->name = TLB_MultiByteToBSTR(fname);
3038 }
3039 ref_type->pImpTLInfo = *import;
3040
3041 /* Store a reference to IDispatch */
3042 if(pTL->dispatch_href == -1 && IsEqualGUID(&(*import)->guid, &IID_StdOle) && type_num == 4)
3043 pTL->dispatch_href = typelib_ref;
3044
3045 } else { /* internal ref */
3046 ref_type->pImpTLInfo = TLB_REF_INTERNAL;
3047 }
3048 ref_type->reference = typelib_ref;
3049 ref_type->index = type_num;
3050
3051 HeapFree(GetProcessHeap(), 0, refname);
3052 list_add_tail(&pTL->ref_list, &ref_type->entry);
3053
3054 table->refs[ref] = typelib_ref;
3055 typelib_ref += 4;
3056 }
3057 if((BYTE)*name != SLTG_REF_MAGIC)
3058 FIXME("End of ref block magic = %x\n", *name);
3059 dump_TLBRefType(pTL);
3060 return table;
3061 }
3062
3063 static char *SLTG_DoImpls(char *pBlk, ITypeInfoImpl *pTI,
3064 BOOL OneOnly, const sltg_ref_lookup_t *ref_lookup)
3065 {
3066 SLTG_ImplInfo *info;
3067 TLBImplType **ppImplType = &pTI->impltypelist;
3068 /* I don't really get this structure, usually it's 0x16 bytes
3069 long, but iuser.tlb contains some that are 0x18 bytes long.
3070 That's ok because we can use the next ptr to jump to the next
3071 one. But how do we know the length of the last one? The WORD
3072 at offs 0x8 might be the clue. For now I'm just assuming that
3073 the last one is the regular 0x16 bytes. */
3074
3075 info = (SLTG_ImplInfo*)pBlk;
3076 while(1) {
3077 *ppImplType = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3078 sizeof(**ppImplType));
3079 sltg_get_typelib_ref(ref_lookup, info->ref, &(*ppImplType)->hRef);
3080 (*ppImplType)->implflags = info->impltypeflags;
3081 pTI->TypeAttr.cImplTypes++;
3082 ppImplType = &(*ppImplType)->next;
3083
3084 if(info->next == 0xffff)
3085 break;
3086 if(OneOnly)
3087 FIXME("Interface inheriting more than one interface\n");
3088 info = (SLTG_ImplInfo*)(pBlk + info->next);
3089 }
3090 info++; /* see comment at top of function */
3091 return (char*)info;
3092 }
3093
3094 static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsigned short cVars,
3095 const char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
3096 {
3097 TLBVarDesc **ppVarDesc = &pTI->varlist;
3098 BSTR bstrPrevName = NULL;
3099 SLTG_Variable *pItem;
3100 unsigned short i;
3101 WORD *pType;
3102 char buf[300];
3103
3104 for(pItem = (SLTG_Variable *)pFirstItem, i = 0; i < cVars;
3105 pItem = (SLTG_Variable *)(pBlk + pItem->next), i++) {
3106
3107 *ppVarDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3108 sizeof(**ppVarDesc));
3109 (*ppVarDesc)->vardesc.memid = pItem->memid;
3110
3111 if (pItem->magic != SLTG_VAR_MAGIC &&
3112 pItem->magic != SLTG_VAR_WITH_FLAGS_MAGIC) {
3113 FIXME_(typelib)("var magic = %02x\n", pItem->magic);
3114 return;
3115 }
3116
3117 if (pItem->name == 0xfffe)
3118 (*ppVarDesc)->Name = SysAllocString(bstrPrevName);
3119 else
3120 (*ppVarDesc)->Name = TLB_MultiByteToBSTR(pItem->name + pNameTable);
3121
3122 TRACE_(typelib)("byte_offs = 0x%x\n", pItem->byte_offs);
3123 TRACE_(typelib)("memid = 0x%x\n", pItem->memid);
3124
3125 if (pItem->flags & 0x40) {
3126 TRACE_(typelib)("VAR_DISPATCH\n");
3127 (*ppVarDesc)->vardesc.varkind = VAR_DISPATCH;
3128 }
3129 else if (pItem->flags & 0x10) {
3130 TRACE_(typelib)("VAR_CONST\n");
3131 (*ppVarDesc)->vardesc.varkind = VAR_CONST;
3132 (*ppVarDesc)->vardesc.u.lpvarValue = HeapAlloc(GetProcessHeap(), 0,
3133 sizeof(VARIANT));
3134 V_VT((*ppVarDesc)->vardesc.u.lpvarValue) = VT_INT;
3135 V_UNION((*ppVarDesc)->vardesc.u.lpvarValue, intVal) =
3136 *(INT*)(pBlk + pItem->byte_offs);
3137 }
3138 else {
3139 TRACE_(typelib)("VAR_PERINSTANCE\n");
3140 (*ppVarDesc)->vardesc.u.oInst = pItem->byte_offs;
3141 (*ppVarDesc)->vardesc.varkind = VAR_PERINSTANCE;
3142 }
3143
3144 if (pItem->magic == SLTG_VAR_WITH_FLAGS_MAGIC)
3145 (*ppVarDesc)->vardesc.wVarFlags = pItem->varflags;
3146
3147 if (pItem->flags & 0x80)
3148 (*ppVarDesc)->vardesc.wVarFlags |= VARFLAG_FREADONLY;
3149
3150 if(pItem->flags & 0x02)
3151 pType = &pItem->type;
3152 else
3153 pType = (WORD*)(pBlk + pItem->type);
3154
3155 if (pItem->flags & ~0xd2)
3156 FIXME_(typelib)("unhandled flags = %02x\n", pItem->flags & ~0xd2);
3157
3158 SLTG_DoElem(pType, pBlk,
3159 &(*ppVarDesc)->vardesc.elemdescVar, ref_lookup);
3160
3161 dump_TypeDesc(&(*ppVarDesc)->vardesc.elemdescVar.tdesc, buf);
3162
3163 bstrPrevName = (*ppVarDesc)->Name;
3164 ppVarDesc = &((*ppVarDesc)->next);
3165 }
3166 pTI->TypeAttr.cVars = cVars;
3167 }
3168
3169 static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI,
3170 unsigned short cFuncs, char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
3171 {
3172 SLTG_Function *pFunc;
3173 unsigned short i;
3174 TLBFuncDesc **ppFuncDesc = &pTI->funclist;
3175
3176 for(pFunc = (SLTG_Function*)pFirstItem, i = 0; i < cFuncs;
3177 pFunc = (SLTG_Function*)(pBlk + pFunc->next), i++) {
3178
3179 int param;
3180 WORD *pType, *pArg;
3181
3182 *ppFuncDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3183 sizeof(**ppFuncDesc));
3184
3185 switch (pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT) {
3186 case SLTG_FUNCTION_MAGIC:
3187 (*ppFuncDesc)->funcdesc.funckind = FUNC_PUREVIRTUAL;
3188 break;
3189 case SLTG_DISPATCH_FUNCTION_MAGIC:
3190 (*ppFuncDesc)->funcdesc.funckind = FUNC_DISPATCH;
3191 break;
3192 case SLTG_STATIC_FUNCTION_MAGIC:
3193 (*ppFuncDesc)->funcdesc.funckind = FUNC_STATIC;
3194 break;
3195 default:
3196 FIXME("unimplemented func magic = %02x\n", pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT);
3197 HeapFree(GetProcessHeap(), 0, *ppFuncDesc);
3198 *ppFuncDesc = NULL;
3199 return;
3200 }
3201 (*ppFuncDesc)->Name = TLB_MultiByteToBSTR(pFunc->name + pNameTable);
3202
3203 (*ppFuncDesc)->funcdesc.memid = pFunc->dispid;
3204 (*ppFuncDesc)->funcdesc.invkind = pFunc->inv >> 4;
3205 (*ppFuncDesc)->funcdesc.callconv = pFunc->nacc & 0x7;
3206 (*ppFuncDesc)->funcdesc.cParams = pFunc->nacc >> 3;
3207 (*ppFuncDesc)->funcdesc.cParamsOpt = (pFunc->retnextopt & 0x7e) >> 1;
3208 (*ppFuncDesc)->funcdesc.oVft = pFunc->vtblpos;
3209
3210 if(pFunc->magic & SLTG_FUNCTION_FLAGS_PRESENT)
3211 (*ppFuncDesc)->funcdesc.wFuncFlags = pFunc->funcflags;
3212
3213 if(pFunc->retnextopt & 0x80)
3214 pType = &pFunc->rettype;
3215 else
3216 pType = (WORD*)(pBlk + pFunc->rettype);
3217
3218 SLTG_DoElem(pType, pBlk, &(*ppFuncDesc)->funcdesc.elemdescFunc, ref_lookup);
3219
3220 (*ppFuncDesc)->funcdesc.lprgelemdescParam =
3221 HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3222 (*ppFuncDesc)->funcdesc.cParams * sizeof(ELEMDESC));
3223 (*ppFuncDesc)->pParamDesc =
3224 HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3225 (*ppFuncDesc)->funcdesc.cParams * sizeof(TLBParDesc));
3226
3227 pArg = (WORD*)(pBlk + pFunc->arg_off);
3228
3229 for(param = 0; param < (*ppFuncDesc)->funcdesc.cParams; param++) {
3230 char *paramName = pNameTable + *pArg;
3231 BOOL HaveOffs;
3232 /* If arg type follows then paramName points to the 2nd
3233 letter of the name, else the next WORD is an offset to
3234 the arg type and paramName points to the first letter.
3235 So let's take one char off paramName and see if we're
3236 pointing at an alpha-numeric char. However if *pArg is
3237 0xffff or 0xfffe then the param has no name, the former
3238 meaning that the next WORD is the type, the latter
3239 meaning that the next WORD is an offset to the type. */
3240
3241 HaveOffs = FALSE;
3242 if(*pArg == 0xffff)
3243 paramName = NULL;
3244 else if(*pArg == 0xfffe) {
3245 paramName = NULL;
3246 HaveOffs = TRUE;
3247 }
3248 else if(paramName[-1] && !isalnum(paramName[-1]))
3249 HaveOffs = TRUE;
3250
3251 pArg++;
3252
3253 if(HaveOffs) { /* the next word is an offset to type */
3254 pType = (WORD*)(pBlk + *pArg);
3255 SLTG_DoElem(pType, pBlk,
3256 &(*ppFuncDesc)->funcdesc.lprgelemdescParam[param], ref_lookup);
3257 pArg++;
3258 } else {
3259 if(paramName)
3260 paramName--;
3261 pArg = SLTG_DoElem(pArg, pBlk,
3262 &(*ppFuncDesc)->funcdesc.lprgelemdescParam[param], ref_lookup);
3263 }
3264
3265 /* Are we an optional param ? */
3266 if((*ppFuncDesc)->funcdesc.cParams - param <=
3267 (*ppFuncDesc)->funcdesc.cParamsOpt)
3268 (*ppFuncDesc)->funcdesc.lprgelemdescParam[param].u.paramdesc.wParamFlags |= PARAMFLAG_FOPT;
3269
3270 if(paramName) {
3271 (*ppFuncDesc)->pParamDesc[param].Name =
3272 TLB_MultiByteToBSTR(paramName);
3273 }
3274 }
3275
3276 ppFuncDesc = &((*ppFuncDesc)->next);
3277 if(pFunc->next == 0xffff) break;
3278 }
3279 pTI->TypeAttr.cFuncs = cFuncs;
3280 }
3281
3282 static void SLTG_ProcessCoClass(char *pBlk, ITypeInfoImpl *pTI,
3283 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3284 SLTG_TypeInfoTail *pTITail)
3285 {
3286 char *pFirstItem;
3287 sltg_ref_lookup_t *ref_lookup = NULL;
3288
3289 if(pTIHeader->href_table != 0xffffffff) {
3290 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3291 pNameTable);
3292 }
3293
3294 pFirstItem = pBlk;
3295
3296 if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
3297 SLTG_DoImpls(pFirstItem, pTI, FALSE, ref_lookup);
3298 }
3299 HeapFree(GetProcessHeap(), 0, ref_lookup);
3300 }
3301
3302
3303 static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
3304 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3305 const SLTG_TypeInfoTail *pTITail)
3306 {
3307 char *pFirstItem;
3308 sltg_ref_lookup_t *ref_lookup = NULL;
3309
3310 if(pTIHeader->href_table != 0xffffffff) {
3311 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3312 pNameTable);
3313 }
3314
3315 pFirstItem = pBlk;
3316
3317 if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
3318 SLTG_DoImpls(pFirstItem, pTI, TRUE, ref_lookup);
3319 }
3320
3321 if (pTITail->funcs_off != 0xffff)
3322 SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3323
3324 HeapFree(GetProcessHeap(), 0, ref_lookup);
3325
3326 if (TRACE_ON(typelib))
3327 dump_TLBFuncDesc(pTI->funclist);
3328 }
3329
3330 static void SLTG_ProcessRecord(char *pBlk, ITypeInfoImpl *pTI,
3331 const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3332 const SLTG_TypeInfoTail *pTITail)
3333 {
3334 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
3335 }
3336
3337 static void SLTG_ProcessAlias(char *pBlk, ITypeInfoImpl *pTI,
3338 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3339 const SLTG_TypeInfoTail *pTITail)
3340 {
3341 WORD *pType;
3342 sltg_ref_lookup_t *ref_lookup = NULL;
3343
3344 if (pTITail->simple_alias) {
3345 /* if simple alias, no more processing required */
3346 pTI->TypeAttr.tdescAlias.vt = pTITail->tdescalias_vt;
3347 return;
3348 }
3349
3350 if(pTIHeader->href_table != 0xffffffff) {
3351 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3352 pNameTable);
3353 }
3354
3355 /* otherwise it is an offset to a type */
3356 pType = (WORD *)(pBlk + pTITail->tdescalias_vt);
3357
3358 SLTG_DoType(pType, pBlk, &pTI->TypeAttr.tdescAlias, ref_lookup);
3359
3360 HeapFree(GetProcessHeap(), 0, ref_lookup);
3361 }
3362
3363 static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI,
3364 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3365 const SLTG_TypeInfoTail *pTITail)
3366 {
3367 sltg_ref_lookup_t *ref_lookup = NULL;
3368 if (pTIHeader->href_table != 0xffffffff)
3369 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3370 pNameTable);
3371
3372 if (pTITail->vars_off != 0xffff)
3373 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
3374
3375 if (pTITail->funcs_off != 0xffff)
3376 SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3377
3378 /* this is necessary to cope with MSFT typelibs that set cFuncs to the number
3379 * of dispinterface functions including the IDispatch ones, so
3380 * ITypeInfo::GetFuncDesc takes the real value for cFuncs from cbSizeVft */
3381 pTI->TypeAttr.cbSizeVft = pTI->TypeAttr.cFuncs * sizeof(void *);
3382
3383 HeapFree(GetProcessHeap(), 0, ref_lookup);
3384 if (TRACE_ON(typelib))
3385 dump_TLBFuncDesc(pTI->funclist);
3386 }
3387
3388 static void SLTG_ProcessEnum(char *pBlk, ITypeInfoImpl *pTI,
3389 const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3390 const SLTG_TypeInfoTail *pTITail)
3391 {
3392 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
3393 }
3394
3395 static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI,
3396 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3397 const SLTG_TypeInfoTail *pTITail)
3398 {
3399 sltg_ref_lookup_t *ref_lookup = NULL;
3400 if (pTIHeader->href_table != 0xffffffff)
3401 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3402 pNameTable);
3403
3404 if (pTITail->vars_off != 0xffff)
3405 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
3406
3407 if (pTITail->funcs_off != 0xffff)
3408 SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3409 HeapFree(GetProcessHeap(), 0, ref_lookup);
3410 }
3411
3412 /* Because SLTG_OtherTypeInfo is such a painful struct, we make a more
3413 managable copy of it into this */
3414 typedef struct {
3415 WORD small_no;
3416 char *index_name;
3417 char *other_name;
3418 WORD res1a;
3419 WORD name_offs;
3420 WORD more_bytes;
3421 char *extra;
3422 WORD res20;
3423 DWORD helpcontext;
3424 WORD res26;
3425 GUID uuid;
3426 } SLTG_InternalOtherTypeInfo;
3427
3428 /****************************************************************************
3429 * ITypeLib2_Constructor_SLTG
3430 *
3431 * loading a SLTG typelib from an in-memory image
3432 */
3433 static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
3434 {
3435 ITypeLibImpl *pTypeLibImpl;
3436 SLTG_Header *pHeader;
3437 SLTG_BlkEntry *pBlkEntry;
3438 SLTG_Magic *pMagic;
3439 SLTG_Index *pIndex;
3440 SLTG_Pad9 *pPad9;
3441 LPVOID pBlk, pFirstBlk;
3442 SLTG_LibBlk *pLibBlk;
3443 SLTG_InternalOtherTypeInfo *pOtherTypeInfoBlks;
3444 char *pAfterOTIBlks = NULL;
3445 char *pNameTable, *ptr;
3446 int i;
3447 DWORD len, order;
3448 ITypeInfoImpl **ppTypeInfoImpl;
3449
3450 TRACE_(typelib)("%p, TLB length = %d\n", pLib, dwTLBLength);
3451
3452
3453 pTypeLibImpl = TypeLibImpl_Constructor();
3454 if (!pTypeLibImpl) return NULL;
3455
3456 pHeader = pLib;
3457
3458 TRACE_(typelib)("header:\n");
3459 TRACE_(typelib)("\tmagic=0x%08x, file blocks = %d\n", pHeader->SLTG_magic,
3460 pHeader->nrOfFileBlks );
3461 if (pHeader->SLTG_magic != SLTG_SIGNATURE) {
3462 FIXME("Header type magic 0x%08x not supported.\n",
3463 pHeader->SLTG_magic);
3464 return NULL;
3465 }
3466
3467 /* There are pHeader->nrOfFileBlks - 2 TypeInfo records in this typelib */
3468 pTypeLibImpl->TypeInfoCount = pHeader->nrOfFileBlks - 2;
3469
3470 /* This points to pHeader->nrOfFileBlks - 1 of SLTG_BlkEntry */
3471 pBlkEntry = (SLTG_BlkEntry*)(pHeader + 1);
3472
3473 /* Next we have a magic block */
3474 pMagic = (SLTG_Magic*)(pBlkEntry + pHeader->nrOfFileBlks - 1);
3475
3476 /* Let's see if we're still in sync */
3477 if(memcmp(pMagic->CompObj_magic, SLTG_COMPOBJ_MAGIC,
3478 sizeof(SLTG_COMPOBJ_MAGIC))) {
3479 FIXME("CompObj magic = %s\n", pMagic->CompObj_magic);
3480 return NULL;
3481 }
3482 if(memcmp(pMagic->dir_magic, SLTG_DIR_MAGIC,
3483 sizeof(SLTG_DIR_MAGIC))) {
3484 FIXME("dir magic = %s\n", pMagic->dir_magic);
3485 return NULL;
3486 }
3487
3488 pIndex = (SLTG_Index*)(pMagic+1);
3489
3490 pPad9 = (SLTG_Pad9*)(pIndex + pTypeLibImpl->TypeInfoCount);
3491
3492 pFirstBlk = (LPVOID)(pPad9 + 1);
3493
3494 /* We'll set up a ptr to the main library block, which is the last one. */
3495
3496 for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
3497 pBlkEntry[order].next != 0;
3498 order = pBlkEntry[order].next - 1, i++) {
3499 pBlk = (char*)pBlk + pBlkEntry[order].len;
3500 }
3501 pLibBlk = pBlk;
3502
3503 len = SLTG_ReadLibBlk(pLibBlk, pTypeLibImpl);
3504
3505 /* Now there's 0x40 bytes of 0xffff with the numbers 0 to TypeInfoCount
3506 interspersed */
3507
3508 len += 0x40;
3509
3510 /* And now TypeInfoCount of SLTG_OtherTypeInfo */
3511
3512 pOtherTypeInfoBlks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3513 sizeof(*pOtherTypeInfoBlks) *
3514 pTypeLibImpl->TypeInfoCount);
3515
3516
3517 ptr = (char*)pLibBlk + len;
3518
3519 for(i = 0; i < pTypeLibImpl->TypeInfoCount; i++) {
3520 WORD w, extra;
3521 len = 0;
3522
3523 pOtherTypeInfoBlks[i].small_no = *(WORD*)ptr;
3524
3525 w = *(WORD*)(ptr + 2);
3526 if(w != 0xffff) {
3527 len += w;
3528 pOtherTypeInfoBlks[i].index_name = HeapAlloc(GetProcessHeap(),0,
3529 w+1);
3530 memcpy(pOtherTypeInfoBlks[i].index_name, ptr + 4, w);
3531 pOtherTypeInfoBlks[i].index_name[w] = '\0';
3532 }
3533 w = *(WORD*)(ptr + 4 + len);
3534 if(w != 0xffff) {
3535 TRACE_(typelib)("\twith %s\n", debugstr_an(ptr + 6 + len, w));
3536 len += w;
3537 pOtherTypeInfoBlks[i].other_name = HeapAlloc(GetProcessHeap(),0,
3538 w+1);
3539 memcpy(pOtherTypeInfoBlks[i].other_name, ptr + 6 + len, w);
3540 pOtherTypeInfoBlks[i].other_name[w] = '\0';
3541 }
3542 pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + len + 6);
3543 pOtherTypeInfoBlks[i].name_offs = *(WORD*)(ptr + len + 8);
3544 extra = pOtherTypeInfoBlks[i].more_bytes = *(WORD*)(ptr + 10 + len);
3545 if(extra) {
3546 pOtherTypeInfoBlks[i].extra = HeapAlloc(GetProcessHeap(),0,
3547 extra);
3548 memcpy(pOtherTypeInfoBlks[i].extra, ptr + 12, extra);
3549 len += extra;
3550 }
3551 pOtherTypeInfoBlks[i].res20 = *(WORD*)(ptr + 12 + len);
3552 pOtherTypeInfoBlks[i].helpcontext = *(DWORD*)(ptr + 14 + len);
3553 pOtherTypeInfoBlks[i].res26 = *(WORD*)(ptr + 18 + len);
3554 memcpy(&pOtherTypeInfoBlks[i].uuid, ptr + 20 + len, sizeof(GUID));
3555 len += sizeof(SLTG_OtherTypeInfo);
3556 ptr += len;
3557 }
3558
3559 pAfterOTIBlks = ptr;
3560
3561 /* Skip this WORD and get the next DWORD */
3562 len = *(DWORD*)(pAfterOTIBlks + 2);
3563
3564 /* Now add this to pLibBLk look at what we're pointing at and
3565 possibly add 0x20, then add 0x216, sprinkle a bit a magic
3566 dust and we should be pointing at the beginning of the name
3567 table */
3568
3569 pNameTable = (char*)pLibBlk + len;
3570
3571 switch(*(WORD*)pNameTable) {
3572 case 0xffff:
3573 break;
3574 case 0x0200:
3575 pNameTable += 0x20;
3576 break;
3577 default:
3578 FIXME("pNameTable jump = %x\n", *(WORD*)pNameTable);
3579 break;
3580 }
3581
3582 pNameTable += 0x216;
3583
3584 pNameTable += 2;
3585
3586 TRACE("Library name is %s\n", pNameTable + pLibBlk->name);
3587
3588 pTypeLibImpl->Name = TLB_MultiByteToBSTR(pNameTable + pLibBlk->name);
3589
3590
3591 /* Hopefully we now have enough ptrs set up to actually read in
3592 some TypeInfos. It's not clear which order to do them in, so
3593 I'll just follow the links along the BlkEntry chain and read
3594 them in the order in which they are in the file */
3595
3596 ppTypeInfoImpl = &(pTypeLibImpl->pTypeInfo);
3597
3598 for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
3599 pBlkEntry[order].next != 0;
3600 order = pBlkEntry[order].next - 1, i++) {
3601
3602 SLTG_TypeInfoHeader *pTIHeader;
3603 SLTG_TypeInfoTail *pTITail;
3604 SLTG_MemberHeader *pMemHeader;
3605
3606 if(strcmp(pBlkEntry[order].index_string + (char*)pMagic,
3607 pOtherTypeInfoBlks[i].index_name)) {
3608 FIXME("Index strings don't match\n");
3609 return NULL;
3610 }
3611
3612 pTIHeader = pBlk;
3613 if(pTIHeader->magic != SLTG_TIHEADER_MAGIC) {
3614 FIXME("TypeInfoHeader magic = %04x\n", pTIHeader->magic);
3615 return NULL;
3616 }
3617 TRACE("pTIHeader->res06 = %x, pTIHeader->res0e = %x, pTIHeader->res16 = %x, pTIHeader->res1e = %x\n",
3618 pTIHeader->res06, pTIHeader->res0e, pTIHeader->res16, pTIHeader->res1e);
3619
3620 *ppTypeInfoImpl = (ITypeInfoImpl*)ITypeInfo_Constructor();
3621 (*ppTypeInfoImpl)->pTypeLib = pTypeLibImpl;
3622 (*ppTypeInfoImpl)->index = i;
3623 (*ppTypeInfoImpl)->Name = TLB_MultiByteToBSTR(
3624 pOtherTypeInfoBlks[i].name_offs +
3625 pNameTable);
3626 (*ppTypeInfoImpl)->dwHelpContext = pOtherTypeInfoBlks[i].helpcontext;
3627 (*ppTypeInfoImpl)->TypeAttr.guid = pOtherTypeInfoBlks[i].uuid;
3628 (*ppTypeInfoImpl)->TypeAttr.typekind = pTIHeader->typekind;
3629 (*ppTypeInfoImpl)->TypeAttr.wMajorVerNum = pTIHeader->major_version;
3630 (*ppTypeInfoImpl)->TypeAttr.wMinorVerNum = pTIHeader->minor_version;
3631 (*ppTypeInfoImpl)->TypeAttr.wTypeFlags =
3632 (pTIHeader->typeflags1 >> 3) | (pTIHeader->typeflags2 << 5);
3633
3634 if((pTIHeader->typeflags1 & 7) != 2)
3635 FIXME("typeflags1 = %02x\n", pTIHeader->typeflags1);
3636 if(pTIHeader->typeflags3 != 2)
3637 FIXME("typeflags3 = %02x\n", pTIHeader->typeflags3);
3638
3639 TRACE("TypeInfo %s of kind %s guid %s typeflags %04x\n",
3640 debugstr_w((*ppTypeInfoImpl)->Name),
3641 typekind_desc[pTIHeader->typekind],
3642 debugstr_guid(&(*ppTypeInfoImpl)->TypeAttr.guid),
3643 (*ppTypeInfoImpl)->TypeAttr.wTypeFlags);
3644
3645 pMemHeader = (SLTG_MemberHeader*)((char *)pBlk + pTIHeader->elem_table);
3646
3647 pTITail = (SLTG_TypeInfoTail*)((char *)(pMemHeader + 1) + pMemHeader->cbExtra);
3648
3649 (*ppTypeInfoImpl)->TypeAttr.cbAlignment = pTITail->cbAlignment;
3650 (*ppTypeInfoImpl)->TypeAttr.cbSizeInstance = pTITail->cbSizeInstance;
3651 (*ppTypeInfoImpl)->TypeAttr.cbSizeVft = pTITail->cbSizeVft;
3652
3653 switch(pTIHeader->typekind) {
3654 case TKIND_ENUM:
3655 SLTG_ProcessEnum((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3656 pTIHeader, pTITail);
3657 break;
3658
3659 case TKIND_RECORD:
3660 SLTG_ProcessRecord((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3661 pTIHeader, pTITail);
3662 break;
3663
3664 case TKIND_INTERFACE:
3665 SLTG_ProcessInterface((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3666 pTIHeader, pTITail);
3667 break;
3668
3669 case TKIND_COCLASS:
3670 SLTG_ProcessCoClass((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3671 pTIHeader, pTITail);
3672 break;
3673
3674 case TKIND_ALIAS:
3675 SLTG_ProcessAlias((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3676 pTIHeader, pTITail);
3677 break;
3678
3679 case TKIND_DISPATCH:
3680 SLTG_ProcessDispatch((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3681 pTIHeader, pTITail);
3682 break;
3683
3684 case TKIND_MODULE:
3685 SLTG_ProcessModule((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3686 pTIHeader, pTITail);
3687 break;
3688
3689 default:
3690 FIXME("Not processing typekind %d\n", pTIHeader->typekind);
3691 break;
3692
3693 }
3694
3695 if(pTITail) { /* could get cFuncs, cVars and cImplTypes from here
3696 but we've already set those */
3697 #define X(x) TRACE_(typelib)("tt "#x": %x\n",pTITail->res##x);
3698 X(06);
3699 X(16);
3700 X(18);
3701 X(1a);
3702 X(1e);
3703 X(24);
3704 X(26);
3705 X(2a);
3706 X(2c);
3707 X(2e);
3708 X(30);
3709 X(32);
3710 X(34);
3711 }
3712 ppTypeInfoImpl = &((*ppTypeInfoImpl)->next);
3713 pBlk = (char*)pBlk + pBlkEntry[order].len;
3714 }
3715
3716 if(i != pTypeLibImpl->TypeInfoCount) {
3717 FIXME("Somehow processed %d TypeInfos\n", i);
3718 return NULL;
3719 }
3720
3721 HeapFree(GetProcessHeap(), 0, pOtherTypeInfoBlks);
3722 return (ITypeLib2*)pTypeLibImpl;
3723 }
3724
3725 /* ITypeLib::QueryInterface
3726 */
3727 static HRESULT WINAPI ITypeLib2_fnQueryInterface(
3728 ITypeLib2 * iface,
3729 REFIID riid,
3730 VOID **ppvObject)
3731 {
3732 ITypeLibImpl *This = (ITypeLibImpl *)iface;
3733
3734 TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
3735
3736 *ppvObject=NULL;
3737 if(IsEqualIID(riid, &IID_IUnknown) ||
3738 IsEqualIID(riid,&IID_ITypeLib)||
3739 IsEqualIID(riid,&IID_ITypeLib2))
3740 {
3741 *ppvObject = This;
3742 }
3743
3744 if(*ppvObject)
3745 {
3746 ITypeLib2_AddRef(iface);
3747 TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
3748 return S_OK;
3749 }
3750 TRACE("-- Interface: E_NOINTERFACE\n");
3751 return E_NOINTERFACE;
3752 }
3753
3754 /* ITypeLib::AddRef
3755 */
3756 static ULONG WINAPI ITypeLib2_fnAddRef( ITypeLib2 *iface)
3757 {
3758 ITypeLibImpl *This = (ITypeLibImpl *)iface;
3759 ULONG ref = InterlockedIncrement(&This->ref);
3760
3761 TRACE("(%p)->ref was %u\n",This, ref - 1);
3762
3763 return ref;
3764 }
3765
3766 /* ITypeLib::Release
3767 */
3768 static ULONG WINAPI ITypeLib2_fnRelease( ITypeLib2 *iface)
3769 {
3770 ITypeLibImpl *This = (ITypeLibImpl *)iface;
3771 ULONG ref = InterlockedDecrement(&This->ref);
3772
3773 TRACE("(%p)->(%u)\n",This, ref);
3774
3775 if (!ref)
3776 {
3777 TLBImpLib *pImpLib, *pImpLibNext;
3778 TLBCustData *pCustData, *pCustDataNext;
3779 TLBRefType *ref_type;
3780 void *cursor2;
3781 int i;
3782
3783 /* remove cache entry */
3784 if(This->path)
3785 {
3786 TRACE("removing from cache list\n");
3787 EnterCriticalSection(&cache_section);
3788 if (This->next) This->next->prev = This->prev;
3789 if (This->prev) This->prev->next = This->next;
3790 else tlb_cache_first = This->next;
3791 LeaveCriticalSection(&cache_section);
3792 HeapFree(GetProcessHeap(), 0, This->path);
3793 }
3794 TRACE(" destroying ITypeLib(%p)\n",This);
3795
3796 if (This->Name)
3797 {
3798 SysFreeString(This->Name);
3799 This->Name = NULL;
3800 }
3801
3802 if (This->DocString)
3803 {
3804 SysFreeString(This->DocString);
3805 This->DocString = NULL;
3806 }
3807
3808 if (This->HelpFile)
3809 {
3810 SysFreeString(This->HelpFile);
3811 This->HelpFile = NULL;
3812 }
3813
3814 if (This->HelpStringDll)
3815 {
3816 SysFreeString(This->HelpStringDll);
3817 This->HelpStringDll = NULL;
3818 }
3819
3820 for (pCustData = This->pCustData; pCustData; pCustData = pCustDataNext)
3821 {
3822 VariantClear(&pCustData->data);
3823
3824 pCustDataNext = pCustData->next;
3825 TLB_Free(pCustData);
3826 }
3827
3828 for (i = 0; i < This->ctTypeDesc; i++)
3829 if (This->pTypeDesc[i].vt == VT_CARRAY)
3830 TLB_Free(This->pTypeDesc[i].u.lpadesc);
3831
3832 TLB_Free(This->pTypeDesc);
3833
3834 for (pImpLib = This->pImpLibs; pImpLib; pImpLib = pImpLibNext)
3835 {
3836 if (pImpLib->pImpTypeLib)
3837 ITypeLib_Release((ITypeLib *)pImpLib->pImpTypeLib);
3838 TLB_Free(pImpLib->name);
3839
3840 pImpLibNext = pImpLib->next;
3841 TLB_Free(pImpLib);
3842 }
3843
3844 LIST_FOR_EACH_ENTRY_SAFE(ref_type, cursor2, &This->ref_list, TLBRefType, entry)
3845 {
3846 list_remove(&ref_type->entry);
3847 TLB_Free(ref_type);
3848 }
3849
3850 if (This->pTypeInfo) /* can be NULL */
3851 ITypeInfo_Release((ITypeInfo*) This->pTypeInfo);
3852 HeapFree(GetProcessHeap(),0,This);
3853 return 0;
3854 }
3855
3856 return ref;
3857 }
3858
3859 /* ITypeLib::GetTypeInfoCount
3860 *
3861 * Returns the number of type descriptions in the type library
3862 */
3863 static UINT WINAPI ITypeLib2_fnGetTypeInfoCount( ITypeLib2 *iface)
3864 {
3865 ITypeLibImpl *This = (ITypeLibImpl *)iface;
3866 TRACE("(%p)->count is %d\n",This, This->TypeInfoCount);
3867 return This->TypeInfoCount;
3868 }
3869
3870 /* ITypeLib::GetTypeInfo
3871 *
3872 * retrieves the specified type description in the library.
3873 */
3874 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
3875 ITypeLib2 *iface,
3876 UINT index,
3877 ITypeInfo **ppTInfo)
3878 {
3879 int i;
3880
3881 ITypeLibImpl *This = (ITypeLibImpl *)iface;
3882 ITypeInfoImpl *pTypeInfo = This->pTypeInfo;
3883
3884 TRACE("(%p)->(index=%d)\n", This, index);
3885
3886 if (!ppTInfo) return E_INVALIDARG;
3887
3888 /* search element n in list */
3889 for(i=0; i < index; i++)
3890 {
3891 pTypeInfo = pTypeInfo->next;
3892 if (!pTypeInfo)
3893 {
3894 TRACE("-- element not found\n");
3895 return TYPE_E_ELEMENTNOTFOUND;
3896 }
3897 }
3898
3899 *ppTInfo = (ITypeInfo *) pTypeInfo;
3900
3901 ITypeInfo_AddRef(*ppTInfo);
3902 TRACE("-- found (%p)\n",*ppTInfo);
3903 return S_OK;
3904 }
3905
3906
3907 /* ITypeLibs::GetTypeInfoType
3908 *
3909 * Retrieves the type of a type description.
3910 */
3911 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType(
3912 ITypeLib2 *iface,
3913 UINT index,
3914 TYPEKIND *pTKind)
3915 {
3916 ITypeLibImpl *This = (ITypeLibImpl *)iface;
3917 int i;
3918 ITypeInfoImpl *pTInfo = This->pTypeInfo;
3919
3920 if (ITypeLib2_fnGetTypeInfoCount(iface) < index + 1)
3921 return TYPE_E_ELEMENTNOTFOUND;
3922
3923 TRACE("(%p) index %d\n", This, index);
3924
3925 if(!pTKind) return E_INVALIDARG;
3926
3927 /* search element n in list */
3928 for(i=0; i < index; i++)
3929 {
3930 if(!pTInfo)
3931 {
3932 TRACE("-- element not found\n");
3933 return TYPE_E_ELEMENTNOTFOUND;
3934 }
3935 pTInfo = pTInfo->next;
3936 }
3937
3938 *pTKind = pTInfo->TypeAttr.typekind;
3939 TRACE("-- found Type (%d)\n", *pTKind);
3940 return S_OK;
3941 }
3942
3943 /* ITypeLib::GetTypeInfoOfGuid
3944 *
3945 * Retrieves the type description that corresponds to the specified GUID.
3946 *
3947 */
3948 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid(
3949 ITypeLib2 *iface,
3950 REFGUID guid,
3951 ITypeInfo **ppTInfo)
3952 {
3953 ITypeLibImpl *This = (ITypeLibImpl *)iface;
3954 ITypeInfoImpl *pTypeInfo = This->pTypeInfo; /* head of list */
3955
3956 TRACE("(%p)\n\tguid:\t%s)\n",This,debugstr_guid(guid));
3957
3958 if (!pTypeInfo)
3959 {
3960 WARN("-- element not found\n");
3961 return TYPE_E_ELEMENTNOTFOUND;
3962 }
3963
3964 /* search linked list for guid */
3965 while( !IsEqualIID(guid,&pTypeInfo->TypeAttr.guid) )
3966 {
3967 pTypeInfo = pTypeInfo->next;
3968
3969 if (!pTypeInfo)
3970 {
3971 /* end of list reached */
3972 WARN("-- element not found\n");
3973 return TYPE_E_ELEMENTNOTFOUND;
3974 }
3975 }
3976
3977 TRACE("-- found (%p, %s)\n",
3978 pTypeInfo,
3979 debugstr_w(pTypeInfo->Name));
3980
3981 *ppTInfo = (ITypeInfo*)pTypeInfo;
3982 ITypeInfo_AddRef(*ppTInfo);
3983 return S_OK;
3984 }
3985
3986 /* ITypeLib::GetLibAttr
3987 *
3988 * Retrieves the structure that contains the library's attributes.
3989 *
3990 */
3991 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
3992 ITypeLib2 *iface,
3993 LPTLIBATTR *ppTLibAttr)
3994 {
3995 ITypeLibImpl *This = (ITypeLibImpl *)iface;
3996 TRACE("(%p)\n",This);
3997 *ppTLibAttr = HeapAlloc(GetProcessHeap(), 0, sizeof(**ppTLibAttr));
3998 **ppTLibAttr = This->LibAttr;
3999 return S_OK;
4000 }
4001
4002 /* ITypeLib::GetTypeComp
4003 *
4004 * Enables a client compiler to bind to a library's types, variables,
4005 * constants, and global functions.
4006 *
4007 */
4008 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
4009 ITypeLib2 *iface,
4010 ITypeComp **ppTComp)
4011 {
4012 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4013
4014 TRACE("(%p)->(%p)\n",This,ppTComp);
4015 *ppTComp = (ITypeComp *)&This->lpVtblTypeComp;
4016 ITypeComp_AddRef(*ppTComp);
4017
4018 return S_OK;
4019 }
4020
4021 /* ITypeLib::GetDocumentation
4022 *
4023 * Retrieves the library's documentation string, the complete Help file name
4024 * and path, and the context identifier for the library Help topic in the Help
4025 * file.
4026 *
4027 * On a successful return all non-null BSTR pointers will have been set,
4028 * possibly to NULL.
4029 */
4030 static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
4031 ITypeLib2 *iface,
4032 INT index,
4033 BSTR *pBstrName,
4034 BSTR *pBstrDocString,
4035 DWORD *pdwHelpContext,
4036 BSTR *pBstrHelpFile)
4037 {
4038 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4039
4040 HRESULT result = E_INVALIDARG;
4041
4042 ITypeInfo *pTInfo;
4043
4044
4045 TRACE("(%p) index %d Name(%p) DocString(%p) HelpContext(%p) HelpFile(%p)\n",
4046 This, index,
4047 pBstrName, pBstrDocString,
4048 pdwHelpContext, pBstrHelpFile);
4049
4050 if(index<0)
4051 {
4052 /* documentation for the typelib */
4053 if(pBstrName)
4054 {
4055 if (This->Name)
4056 {
4057 if(!(*pBstrName = SysAllocString(This->Name)))
4058 goto memerr1;
4059 }
4060 else
4061 *pBstrName = NULL;
4062 }
4063 if(pBstrDocString)
4064 {
4065 if (This->DocString)
4066 {
4067 if(!(*pBstrDocString = SysAllocString(This->DocString)))
4068 goto memerr2;
4069 }
4070 else if (This->Name)
4071 {
4072 if(!(*pBstrDocString = SysAllocString(This->Name)))
4073 goto memerr2;
4074 }
4075 else
4076 *pBstrDocString = NULL;
4077 }
4078 if(pdwHelpContext)
4079 {
4080 *pdwHelpContext = This->dwHelpContext;
4081 }
4082 if(pBstrHelpFile)
4083 {
4084 if (This->HelpFile)
4085 {
4086 if(!(*pBstrHelpFile = SysAllocString(This->HelpFile)))
4087 goto memerr3;
4088 }
4089 else
4090 *pBstrHelpFile = NULL;
4091 }
4092
4093 result = S_OK;
4094 }
4095 else
4096 {
4097 /* for a typeinfo */
4098 result = ITypeLib2_fnGetTypeInfo(iface, index, &pTInfo);
4099
4100 if(SUCCEEDED(result))
4101 {
4102 result = ITypeInfo_GetDocumentation(pTInfo,
4103 MEMBERID_NIL,
4104 pBstrName,
4105 pBstrDocString,
4106 pdwHelpContext, pBstrHelpFile);
4107
4108 ITypeInfo_Release(pTInfo);
4109 }
4110 }
4111 return result;
4112 memerr3:
4113 if (pBstrDocString) SysFreeString (*pBstrDocString);
4114 memerr2:
4115 if (pBstrName) SysFreeString (*pBstrName);
4116 memerr1:
4117 return STG_E_INSUFFICIENTMEMORY;
4118 }
4119
4120 /* ITypeLib::IsName
4121 *
4122 * Indicates whether a passed-in string contains the name of a type or member
4123 * described in the library.
4124 *
4125 */
4126 static HRESULT WINAPI ITypeLib2_fnIsName(
4127 ITypeLib2 *iface,
4128 LPOLESTR szNameBuf,
4129 ULONG lHashVal,
4130 BOOL *pfName)
4131 {
4132 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4133 ITypeInfoImpl *pTInfo;
4134 TLBFuncDesc *pFInfo;
4135 TLBVarDesc *pVInfo;
4136 int i;
4137 UINT nNameBufLen = (lstrlenW(szNameBuf)+1)*sizeof(WCHAR);
4138
4139 TRACE("(%p)->(%s,%08x,%p)\n", This, debugstr_w(szNameBuf), lHashVal,
4140 pfName);
4141
4142 *pfName=TRUE;
4143 for(pTInfo=This->pTypeInfo;pTInfo;pTInfo=pTInfo->next){
4144 if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4145 for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
4146 if(!memcmp(szNameBuf,pFInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4147 for(i=0;i<pFInfo->funcdesc.cParams;i++)
4148 if(!memcmp(szNameBuf,pFInfo->pParamDesc[i].Name, nNameBufLen))
4149 goto ITypeLib2_fnIsName_exit;
4150 }
4151 for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next)
4152 if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4153
4154 }
4155 *pfName=FALSE;
4156
4157 ITypeLib2_fnIsName_exit:
4158 TRACE("(%p)slow! search for %s: %s found!\n", This,
4159 debugstr_w(szNameBuf), *pfName?"NOT":"");
4160
4161 return S_OK;
4162 }
4163
4164 /* ITypeLib::FindName
4165 *
4166 * Finds occurrences of a type description in a type library. This may be used
4167 * to quickly verify that a name exists in a type library.
4168 *
4169 */
4170 static HRESULT WINAPI ITypeLib2_fnFindName(
4171 ITypeLib2 *iface,
4172 LPOLESTR szNameBuf,
4173 ULONG lHashVal,
4174 ITypeInfo **ppTInfo,
4175 MEMBERID *rgMemId,
4176 UINT16 *pcFound)
4177 {
4178 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4179 ITypeInfoImpl *pTInfo;
4180 TLBFuncDesc *pFInfo;
4181 TLBVarDesc *pVInfo;
4182 int i,j = 0;
4183 UINT nNameBufLen = (lstrlenW(szNameBuf)+1)*sizeof(WCHAR);
4184
4185 for(pTInfo=This->pTypeInfo;pTInfo && j<*pcFound; pTInfo=pTInfo->next){
4186 if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnFindName_exit;
4187 for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
4188 if(!memcmp(szNameBuf,pFInfo->Name,nNameBufLen)) goto ITypeLib2_fnFindName_exit;
4189 for(i=0;i<pFInfo->funcdesc.cParams;i++) {
4190 if(!memcmp(szNameBuf,pFInfo->pParamDesc[i].Name,nNameBufLen))
4191 goto ITypeLib2_fnFindName_exit;
4192 }
4193 }
4194 for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next)
4195 if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnFindName_exit;
4196 continue;
4197 ITypeLib2_fnFindName_exit:
4198 ITypeInfo_AddRef((ITypeInfo*)pTInfo);
4199 ppTInfo[j]=(LPTYPEINFO)pTInfo;
4200 j++;
4201 }
4202 TRACE("(%p)slow! search for %d with %s: found %d TypeInfo's!\n",
4203 This, *pcFound, debugstr_w(szNameBuf), j);
4204
4205 *pcFound=j;
4206
4207 return S_OK;
4208 }
4209
4210 /* ITypeLib::ReleaseTLibAttr
4211 *
4212 * Releases the TLIBATTR originally obtained from ITypeLib::GetLibAttr.
4213 *
4214 */
4215 static VOID WINAPI ITypeLib2_fnReleaseTLibAttr(
4216 ITypeLib2 *iface,
4217 TLIBATTR *pTLibAttr)
4218 {
4219 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4220 TRACE("freeing (%p)\n",This);
4221 HeapFree(GetProcessHeap(),0,pTLibAttr);
4222
4223 }
4224
4225 /* ITypeLib2::GetCustData
4226 *
4227 * gets the custom data
4228 */
4229 static HRESULT WINAPI ITypeLib2_fnGetCustData(
4230 ITypeLib2 * iface,
4231 REFGUID guid,
4232 VARIANT *pVarVal)
4233 {
4234 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4235 TLBCustData *pCData;
4236
4237 for(pCData=This->pCustData; pCData; pCData = pCData->next)
4238 {
4239 if( IsEqualIID(guid, &pCData->guid)) break;
4240 }
4241
4242 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
4243
4244 if(pCData)
4245 {
4246 VariantInit( pVarVal);
4247 VariantCopy( pVarVal, &pCData->data);
4248 return S_OK;
4249 }
4250 return E_INVALIDARG; /* FIXME: correct? */
4251 }
4252
4253 /* ITypeLib2::GetLibStatistics
4254 *
4255 * Returns statistics about a type library that are required for efficient
4256 * sizing of hash tables.
4257 *
4258 */
4259 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
4260 ITypeLib2 * iface,
4261 ULONG *pcUniqueNames,
4262 ULONG *pcchUniqueNames)
4263 {
4264 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4265
4266 FIXME("(%p): stub!\n", This);
4267
4268 if(pcUniqueNames) *pcUniqueNames=1;
4269 if(pcchUniqueNames) *pcchUniqueNames=1;
4270 return S_OK;
4271 }
4272
4273 /* ITypeLib2::GetDocumentation2
4274 *
4275 * Retrieves the library's documentation string, the complete Help file name
4276 * and path, the localization context to use, and the context ID for the
4277 * library Help topic in the Help file.
4278 *
4279 */
4280 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
4281 ITypeLib2 * iface,
4282 INT index,
4283 LCID lcid,
4284 BSTR *pbstrHelpString,
4285 DWORD *pdwHelpStringContext,
4286 BSTR *pbstrHelpStringDll)
4287 {
4288 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4289 HRESULT result;
4290 ITypeInfo *pTInfo;
4291
4292 FIXME("(%p) index %d lcid %d half implemented stub!\n", This, index, lcid);
4293
4294 /* the help string should be obtained from the helpstringdll,
4295 * using the _DLLGetDocumentation function, based on the supplied
4296 * lcid. Nice to do sometime...
4297 */
4298 if(index<0)
4299 {
4300 /* documentation for the typelib */
4301 if(pbstrHelpString)
4302 *pbstrHelpString=SysAllocString(This->DocString);
4303 if(pdwHelpStringContext)
4304 *pdwHelpStringContext=This->dwHelpContext;
4305 if(pbstrHelpStringDll)
4306 *pbstrHelpStringDll=SysAllocString(This->HelpStringDll);
4307
4308 result = S_OK;
4309 }
4310 else
4311 {
4312 /* for a typeinfo */
4313 result=ITypeLib2_GetTypeInfo(iface, index, &pTInfo);
4314
4315 if(SUCCEEDED(result))
4316 {
4317 ITypeInfo2 * pTInfo2;
4318 result = ITypeInfo_QueryInterface(pTInfo,
4319 &IID_ITypeInfo2,
4320 (LPVOID*) &pTInfo2);
4321
4322 if(SUCCEEDED(result))
4323 {
4324 result = ITypeInfo2_GetDocumentation2(pTInfo2,
4325 MEMBERID_NIL,
4326 lcid,
4327 pbstrHelpString,
4328 pdwHelpStringContext,
4329 pbstrHelpStringDll);
4330
4331 ITypeInfo2_Release(pTInfo2);
4332 }
4333
4334 ITypeInfo_Release(pTInfo);
4335 }
4336 }
4337 return result;
4338 }
4339
4340 /* ITypeLib2::GetAllCustData
4341 *
4342 * Gets all custom data items for the library.
4343 *
4344 */
4345 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
4346 ITypeLib2 * iface,
4347 CUSTDATA *pCustData)
4348 {
4349 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4350 TLBCustData *pCData;
4351 int i;
4352 TRACE("(%p) returning %d items\n", This, This->ctCustData);
4353 pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
4354 if(pCustData->prgCustData ){
4355 pCustData->cCustData=This->ctCustData;
4356 for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
4357 pCustData->prgCustData[i].guid=pCData->guid;
4358 VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
4359 }
4360 }else{
4361 ERR(" OUT OF MEMORY!\n");
4362 return E_OUTOFMEMORY;
4363 }
4364 return S_OK;
4365 }
4366
4367 static const ITypeLib2Vtbl tlbvt = {
4368 ITypeLib2_fnQueryInterface,
4369 ITypeLib2_fnAddRef,
4370 ITypeLib2_fnRelease,
4371 ITypeLib2_fnGetTypeInfoCount,
4372 ITypeLib2_fnGetTypeInfo,
4373 ITypeLib2_fnGetTypeInfoType,
4374 ITypeLib2_fnGetTypeInfoOfGuid,
4375 ITypeLib2_fnGetLibAttr,
4376 ITypeLib2_fnGetTypeComp,
4377 ITypeLib2_fnGetDocumentation,
4378 ITypeLib2_fnIsName,
4379 ITypeLib2_fnFindName,
4380 ITypeLib2_fnReleaseTLibAttr,
4381
4382 ITypeLib2_fnGetCustData,
4383 ITypeLib2_fnGetLibStatistics,
4384 ITypeLib2_fnGetDocumentation2,
4385 ITypeLib2_fnGetAllCustData
4386 };
4387
4388
4389 static HRESULT WINAPI ITypeLibComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
4390 {
4391 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4392
4393 return ITypeLib2_QueryInterface((ITypeLib *)This, riid, ppv);
4394 }
4395
4396 static ULONG WINAPI ITypeLibComp_fnAddRef(ITypeComp * iface)
4397 {
4398 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4399
4400 return ITypeLib2_AddRef((ITypeLib2 *)This);
4401 }
4402
4403 static ULONG WINAPI ITypeLibComp_fnRelease(ITypeComp * iface)
4404 {
4405 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4406
4407 return ITypeLib2_Release((ITypeLib2 *)This);
4408 }
4409
4410 static HRESULT WINAPI ITypeLibComp_fnBind(
4411 ITypeComp * iface,
4412 OLECHAR * szName,
4413 ULONG lHash,
4414 WORD wFlags,
4415 ITypeInfo ** ppTInfo,
4416 DESCKIND * pDescKind,
4417 BINDPTR * pBindPtr)
4418 {
4419 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4420 ITypeInfoImpl *pTypeInfo;
4421
4422 TRACE("(%s, 0x%x, 0x%x, %p, %p, %p)\n", debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
4423
4424 *pDescKind = DESCKIND_NONE;
4425 pBindPtr->lptcomp = NULL;
4426 *ppTInfo = NULL;
4427
4428 for (pTypeInfo = This->pTypeInfo; pTypeInfo; pTypeInfo = pTypeInfo->next)
4429 {
4430 TRACE("testing %s\n", debugstr_w(pTypeInfo->Name));
4431
4432 /* FIXME: check wFlags here? */
4433 /* FIXME: we should use a hash table to look this info up using lHash
4434 * instead of an O(n) search */
4435 if ((pTypeInfo->TypeAttr.typekind == TKIND_ENUM) ||
4436 (pTypeInfo->TypeAttr.typekind == TKIND_MODULE))
4437 {
4438 if (pTypeInfo->Name && !strcmpW(pTypeInfo->Name, szName))
4439 {
4440 *pDescKind = DESCKIND_TYPECOMP;
4441 pBindPtr->lptcomp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4442 ITypeComp_AddRef(pBindPtr->lptcomp);
4443 TRACE("module or enum: %s\n", debugstr_w(szName));
4444 return S_OK;
4445 }
4446 }
4447
4448 if ((pTypeInfo->TypeAttr.typekind == TKIND_MODULE) ||
4449 (pTypeInfo->TypeAttr.typekind == TKIND_ENUM))
4450 {
4451 ITypeComp *pSubTypeComp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4452 HRESULT hr;
4453
4454 hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
4455 if (SUCCEEDED(hr) && (*pDescKind != DESCKIND_NONE))
4456 {
4457 TRACE("found in module or in enum: %s\n", debugstr_w(szName));
4458 return S_OK;
4459 }
4460 }
4461
4462 if ((pTypeInfo->TypeAttr.typekind == TKIND_COCLASS) &&
4463 (pTypeInfo->TypeAttr.wTypeFlags & TYPEFLAG_FAPPOBJECT))
4464 {
4465 ITypeComp *pSubTypeComp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4466 HRESULT hr;
4467 ITypeInfo *subtypeinfo;
4468 BINDPTR subbindptr;
4469 DESCKIND subdesckind;
4470
4471 hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags,
4472 &subtypeinfo, &subdesckind, &subbindptr);
4473 if (SUCCEEDED(hr) && (subdesckind != DESCKIND_NONE))
4474 {
4475 TYPEDESC tdesc_appobject =
4476 {
4477 {
4478 (TYPEDESC *)pTypeInfo->hreftype
4479 },
4480 VT_USERDEFINED
4481 };
4482 const VARDESC vardesc_appobject =
4483 {
4484 -2, /* memid */
4485 NULL, /* lpstrSchema */
4486 {
4487 0 /* oInst */
4488 },
4489 {
4490 /* ELEMDESC */
4491 {
4492 /* TYPEDESC */
4493 {
4494 &tdesc_appobject
4495 },
4496 VT_PTR
4497 },
4498 },
4499 0, /* wVarFlags */
4500 VAR_STATIC /* varkind */
4501 };
4502
4503 TRACE("found in implicit app object: %s\n", debugstr_w(szName));
4504
4505 /* cleanup things filled in by Bind call so we can put our
4506 * application object data in there instead */
4507 switch (subdesckind)
4508 {
4509 case DESCKIND_FUNCDESC:
4510 ITypeInfo_ReleaseFuncDesc(subtypeinfo, subbindptr.lpfuncdesc);
4511 break;
4512 case DESCKIND_VARDESC:
4513 ITypeInfo_ReleaseVarDesc(subtypeinfo, subbindptr.lpvardesc);
4514 break;
4515 default:
4516 break;
4517 }
4518 if (subtypeinfo) ITypeInfo_Release(subtypeinfo);
4519
4520 if (pTypeInfo->hreftype == -1)
4521 FIXME("no hreftype for interface %p\n", pTypeInfo);
4522
4523 hr = TLB_AllocAndInitVarDesc(&vardesc_appobject, &pBindPtr->lpvardesc);
4524 if (FAILED(hr))
4525 return hr;
4526
4527 *pDescKind = DESCKIND_IMPLICITAPPOBJ;
4528 *ppTInfo = (ITypeInfo *)pTypeInfo;
4529 ITypeInfo_AddRef(*ppTInfo);
4530 return S_OK;
4531 }
4532 }
4533 }
4534
4535 TRACE("name not found %s\n", debugstr_w(szName));
4536 return S_OK;
4537 }
4538
4539 static HRESULT WINAPI ITypeLibComp_fnBindType(
4540 ITypeComp * iface,
4541 OLECHAR * szName,
4542 ULONG lHash,
4543 ITypeInfo ** ppTInfo,
4544 ITypeComp ** ppTComp)
4545 {
4546 FIXME("(%s, %x, %p, %p): stub\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
4547 return E_NOTIMPL;
4548 }
4549
4550 static const ITypeCompVtbl tlbtcvt =
4551 {
4552
4553 ITypeLibComp_fnQueryInterface,
4554 ITypeLibComp_fnAddRef,
4555 ITypeLibComp_fnRelease,
4556
4557 ITypeLibComp_fnBind,
4558 ITypeLibComp_fnBindType
4559 };
4560
4561 /*================== ITypeInfo(2) Methods ===================================*/
4562 static ITypeInfo2 * WINAPI ITypeInfo_Constructor(void)
4563 {
4564 ITypeInfoImpl * pTypeInfoImpl;
4565
4566 pTypeInfoImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeInfoImpl));
4567 if (pTypeInfoImpl)
4568 {
4569 pTypeInfoImpl->lpVtbl = &tinfvt;
4570 pTypeInfoImpl->lpVtblTypeComp = &tcompvt;
4571 pTypeInfoImpl->ref=1;
4572 pTypeInfoImpl->hreftype = -1;
4573 pTypeInfoImpl->TypeAttr.memidConstructor = MEMBERID_NIL;
4574 pTypeInfoImpl->TypeAttr.memidDestructor = MEMBERID_NIL;
4575 }
4576 TRACE("(%p)\n", pTypeInfoImpl);
4577 return (ITypeInfo2*) pTypeInfoImpl;
4578 }
4579
4580 /* ITypeInfo::QueryInterface
4581 */
4582 static HRESULT WINAPI ITypeInfo_fnQueryInterface(
4583 ITypeInfo2 *iface,
4584 REFIID riid,
4585 VOID **ppvObject)
4586 {
4587 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4588
4589 TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
4590
4591 *ppvObject=NULL;
4592 if(IsEqualIID(riid, &IID_IUnknown) ||
4593 IsEqualIID(riid,&IID_ITypeInfo)||
4594 IsEqualIID(riid,&IID_ITypeInfo2))
4595 *ppvObject = This;
4596
4597 if(*ppvObject){
4598 ITypeInfo_AddRef(iface);
4599 TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
4600 return S_OK;
4601 }
4602 TRACE("-- Interface: E_NOINTERFACE\n");
4603 return E_NOINTERFACE;
4604 }
4605
4606 /* ITypeInfo::AddRef
4607 */
4608 static ULONG WINAPI ITypeInfo_fnAddRef( ITypeInfo2 *iface)
4609 {
4610 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4611 ULONG ref = InterlockedIncrement(&This->ref);
4612
4613 ITypeLib2_AddRef((ITypeLib2*)This->pTypeLib);
4614
4615 TRACE("(%p)->ref is %u\n",This, ref);
4616 return ref;
4617 }
4618
4619 /* ITypeInfo::Release
4620 */
4621 static ULONG WINAPI ITypeInfo_fnRelease(ITypeInfo2 *iface)
4622 {
4623 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4624 ULONG ref = InterlockedDecrement(&This->ref);
4625
4626 TRACE("(%p)->(%u)\n",This, ref);
4627
4628 if (ref) {
4629 /* We don't release ITypeLib when ref=0 because
4630 it means that function is called by ITypeLib2_Release */
4631 ITypeLib2_Release((ITypeLib2*)This->pTypeLib);
4632 } else {
4633 TLBFuncDesc *pFInfo, *pFInfoNext;
4634 TLBVarDesc *pVInfo, *pVInfoNext;
4635 TLBImplType *pImpl, *pImplNext;
4636
4637 TRACE("destroying ITypeInfo(%p)\n",This);
4638
4639 if (This->no_free_data)
4640 goto finish_free;
4641
4642 if (This->Name)
4643 {
4644 SysFreeString(This->Name);
4645 This->Name = 0;
4646 }
4647
4648 if (This->DocString)
4649 {
4650 SysFreeString(This->DocString);
4651 This->DocString = 0;
4652 }
4653
4654 if (This->DllName)
4655 {
4656 SysFreeString(This->DllName);
4657 This->DllName = 0;
4658 }
4659
4660 for (pFInfo = This->funclist; pFInfo; pFInfo = pFInfoNext)
4661 {
4662 UINT i;
4663 for(i = 0;i < pFInfo->funcdesc.cParams; i++)
4664 {
4665 ELEMDESC *elemdesc = &pFInfo->funcdesc.lprgelemdescParam[i];
4666 if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4667 {
4668 VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
4669 TLB_Free(elemdesc->u.paramdesc.pparamdescex);
4670 }
4671 SysFreeString(pFInfo->pParamDesc[i].Name);
4672 }
4673 TLB_Free(pFInfo->funcdesc.lprgelemdescParam);
4674 TLB_Free(pFInfo->pParamDesc);
4675 TLB_FreeCustData(pFInfo->pCustData);
4676 if (HIWORD(pFInfo->Entry) != 0 && pFInfo->Entry != (BSTR)-1)
4677 SysFreeString(pFInfo->Entry);
4678 SysFreeString(pFInfo->HelpString);
4679 SysFreeString(pFInfo->Name);
4680
4681 pFInfoNext = pFInfo->next;
4682 TLB_Free(pFInfo);
4683 }
4684 for (pVInfo = This->varlist; pVInfo; pVInfo = pVInfoNext)
4685 {
4686 if (pVInfo->vardesc.varkind == VAR_CONST)
4687 {
4688 VariantClear(pVInfo->vardesc.u.lpvarValue);
4689 TLB_Free(pVInfo->vardesc.u.lpvarValue);
4690 }
4691 TLB_FreeCustData(pVInfo->pCustData);
4692 SysFreeString(pVInfo->Name);
4693 pVInfoNext = pVInfo->next;
4694 TLB_Free(pVInfo);
4695 }
4696 for(pImpl = This->impltypelist; pImpl; pImpl = pImplNext)
4697 {
4698 TLB_FreeCustData(pImpl->pCustData);
4699 pImplNext = pImpl->next;
4700 TLB_Free(pImpl);
4701 }
4702 TLB_FreeCustData(This->pCustData);
4703
4704 finish_free:
4705 if (This->next)
4706 {
4707 ITypeInfo_Release((ITypeInfo*)This->next);
4708 }
4709
4710 HeapFree(GetProcessHeap(),0,This);
4711 return 0;
4712 }
4713 return ref;
4714 }
4715
4716 /* ITypeInfo::GetTypeAttr
4717 *
4718 * Retrieves a TYPEATTR structure that contains the attributes of the type
4719 * description.
4720 *
4721 */
4722 static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( ITypeInfo2 *iface,
4723 LPTYPEATTR *ppTypeAttr)
4724 {
4725 const ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4726 SIZE_T size;
4727
4728 TRACE("(%p)\n",This);
4729
4730 size = sizeof(**ppTypeAttr);
4731 if (This->TypeAttr.typekind == TKIND_ALIAS)
4732 size += TLB_SizeTypeDesc(&This->TypeAttr.tdescAlias, FALSE);
4733
4734 *ppTypeAttr = HeapAlloc(GetProcessHeap(), 0, size);
4735 if (!*ppTypeAttr)
4736 return E_OUTOFMEMORY;
4737
4738 **ppTypeAttr = This->TypeAttr;
4739
4740 if (This->TypeAttr.typekind == TKIND_ALIAS)
4741 TLB_CopyTypeDesc(&(*ppTypeAttr)->tdescAlias,
4742 &This->TypeAttr.tdescAlias, (void *)(*ppTypeAttr + 1));
4743
4744 if((*ppTypeAttr)->typekind == TKIND_DISPATCH) {
4745 (*ppTypeAttr)->cFuncs = (*ppTypeAttr)->cbSizeVft / 4; /* This should include all the inherited
4746 funcs */
4747 (*ppTypeAttr)->cbSizeVft = 28; /* This is always the size of IDispatch's vtbl */
4748 (*ppTypeAttr)->wTypeFlags &= ~TYPEFLAG_FOLEAUTOMATION;
4749 }
4750 return S_OK;
4751 }
4752
4753 /* ITypeInfo::GetTypeComp
4754 *
4755 * Retrieves the ITypeComp interface for the type description, which enables a
4756 * client compiler to bind to the type description's members.
4757 *
4758 */
4759 static HRESULT WINAPI ITypeInfo_fnGetTypeComp( ITypeInfo2 *iface,
4760 ITypeComp * *ppTComp)
4761 {
4762 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4763
4764 TRACE("(%p)->(%p)\n", This, ppTComp);
4765
4766 *ppTComp = (ITypeComp *)&This->lpVtblTypeComp;
4767 ITypeComp_AddRef(*ppTComp);
4768 return S_OK;
4769 }
4770
4771 static SIZE_T TLB_SizeElemDesc( const ELEMDESC *elemdesc )
4772 {
4773 SIZE_T size = TLB_SizeTypeDesc(&elemdesc->tdesc, FALSE);
4774 if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4775 size += sizeof(*elemdesc->u.paramdesc.pparamdescex);
4776 return size;
4777 }
4778
4779 static HRESULT TLB_CopyElemDesc( const ELEMDESC *src, ELEMDESC *dest, char **buffer )
4780 {
4781 *dest = *src;
4782 *buffer = TLB_CopyTypeDesc(&dest->tdesc, &src->tdesc, *buffer);
4783 if (src->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4784 {
4785 const PARAMDESCEX *pparamdescex_src = src->u.paramdesc.pparamdescex;
4786 PARAMDESCEX *pparamdescex_dest = dest->u.paramdesc.pparamdescex = (PARAMDESCEX *)*buffer;
4787 *buffer += sizeof(PARAMDESCEX);
4788 *pparamdescex_dest = *pparamdescex_src;
4789 VariantInit(&pparamdescex_dest->varDefaultValue);
4790 return VariantCopy(&pparamdescex_dest->varDefaultValue,
4791 (VARIANTARG *)&pparamdescex_src->varDefaultValue);
4792 }
4793 else
4794 dest->u.paramdesc.pparamdescex = NULL;
4795 return S_OK;
4796 }
4797
4798 static void TLB_FreeElemDesc( ELEMDESC *elemdesc )
4799 {
4800 if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4801 VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
4802 }
4803
4804 static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_ptr, BOOL dispinterface )
4805 {
4806 FUNCDESC *dest;
4807 char *buffer;
4808 SIZE_T size = sizeof(*src);
4809 SHORT i;
4810 HRESULT hr;
4811
4812 size += sizeof(*src->lprgscode) * src->cScodes;
4813 size += TLB_SizeElemDesc(&src->elemdescFunc);
4814 for (i = 0; i < src->cParams; i++)
4815 {
4816 size += sizeof(ELEMDESC);
4817 size += TLB_SizeElemDesc(&src->lprgelemdescParam[i]);
4818 }
4819
4820 dest = (FUNCDESC *)SysAllocStringByteLen(NULL, size);
4821 if (!dest) return E_OUTOFMEMORY;
4822
4823 *dest = *src;
4824 if (dispinterface) /* overwrite funckind */
4825 dest->funckind = FUNC_DISPATCH;
4826 buffer = (char *)(dest + 1);
4827
4828 dest->lprgscode = (SCODE *)buffer;
4829 memcpy(dest->lprgscode, src->lprgscode, sizeof(*src->lprgscode) * src->cScodes);
4830 buffer += sizeof(*src->lprgscode) * src->cScodes;
4831
4832 hr = TLB_CopyElemDesc(&src->elemdescFunc, &dest->elemdescFunc, &buffer);
4833 if (FAILED(hr))
4834 {
4835 SysFreeString((BSTR)dest);
4836 return hr;
4837 }
4838
4839 dest->lprgelemdescParam = (ELEMDESC *)buffer;
4840 buffer += sizeof(ELEMDESC) * src->cParams;
4841 for (i = 0; i < src->cParams; i++)
4842 {
4843 hr = TLB_CopyElemDesc(&src->lprgelemdescParam[i], &dest->lprgelemdescParam[i], &buffer);
4844 if (FAILED(hr))
4845 break;
4846 }
4847 if (FAILED(hr))
4848 {
4849 /* undo the above actions */
4850 for (i = i - 1; i >= 0; i--)
4851 TLB_FreeElemDesc(&dest->lprgelemdescParam[i]);
4852 TLB_FreeElemDesc(&dest->elemdescFunc);
4853 SysFreeString((BSTR)dest);
4854 return hr;
4855 }
4856
4857 /* special treatment for dispinterfaces: this makes functions appear
4858 * to return their [retval] value when it is really returning an
4859 * HRESULT */
4860 if (dispinterface && dest->elemdescFunc.tdesc.vt == VT_HRESULT)
4861 {
4862 if (dest->cParams &&
4863 (dest->lprgelemdescParam[dest->cParams - 1].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
4864 {
4865 ELEMDESC *elemdesc = &dest->lprgelemdescParam[dest->cParams - 1];
4866 if (elemdesc->tdesc.vt != VT_PTR)
4867 {
4868 ERR("elemdesc should have started with VT_PTR instead of:\n");
4869 if (ERR_ON(ole))
4870 dump_ELEMDESC(elemdesc);
4871 return E_UNEXPECTED;
4872 }
4873
4874 /* copy last parameter to the return value. we are using a flat
4875 * buffer so there is no danger of leaking memory in
4876 * elemdescFunc */
4877 dest->elemdescFunc.tdesc = *elemdesc->tdesc.u.lptdesc;
4878
4879 /* remove the last parameter */
4880 dest->cParams--;
4881 }
4882 else
4883 /* otherwise this function is made to appear to have no return
4884 * value */
4885 dest->elemdescFunc.tdesc.vt = VT_VOID;
4886
4887 }
4888
4889 *dest_ptr = dest;
4890 return S_OK;
4891 }
4892
4893 HRESULT ITypeInfoImpl_GetInternalFuncDesc( ITypeInfo *iface, UINT index, const FUNCDESC **ppFuncDesc )
4894 {
4895 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4896 const TLBFuncDesc *pFDesc;
4897 int i;
4898
4899 for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++, pFDesc=pFDesc->next)
4900 ;
4901
4902 if (pFDesc)
4903 {
4904 *ppFuncDesc = &pFDesc->funcdesc;
4905 return S_OK;
4906 }
4907
4908 return TYPE_E_ELEMENTNOTFOUND;
4909 }
4910
4911 /* internal function to make the inherited interfaces' methods appear
4912 * part of the interface */
4913 static HRESULT ITypeInfoImpl_GetInternalDispatchFuncDesc( ITypeInfo *iface,
4914 UINT index, const FUNCDESC **ppFuncDesc, UINT *funcs, UINT *hrefoffset)
4915 {
4916 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4917 HRESULT hr;
4918 UINT implemented_funcs = 0;
4919
4920 if (funcs)
4921 *funcs = 0;
4922 else
4923 *hrefoffset = DISPATCH_HREF_OFFSET;
4924
4925 if(This->impltypelist)
4926 {
4927 ITypeInfo *pSubTypeInfo;
4928 UINT sub_funcs;
4929
4930 hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef, &pSubTypeInfo);
4931 if (FAILED(hr))
4932 return hr;
4933
4934 hr = ITypeInfoImpl_GetInternalDispatchFuncDesc(pSubTypeInfo,
4935 index,
4936 ppFuncDesc,
4937 &sub_funcs, hrefoffset);
4938 implemented_funcs += sub_funcs;
4939 ITypeInfo_Release(pSubTypeInfo);
4940 if (SUCCEEDED(hr))
4941 return hr;
4942 *hrefoffset += DISPATCH_HREF_OFFSET;
4943 }
4944
4945 if (funcs)
4946 *funcs = implemented_funcs + This->TypeAttr.cFuncs;
4947 else
4948 *hrefoffset = 0;
4949
4950 if (index < implemented_funcs)
4951 return E_INVALIDARG;
4952 return ITypeInfoImpl_GetInternalFuncDesc(iface, index - implemented_funcs,
4953 ppFuncDesc);
4954 }
4955
4956 static inline void ITypeInfoImpl_ElemDescAddHrefOffset( LPELEMDESC pElemDesc, UINT hrefoffset)
4957 {
4958 TYPEDESC *pTypeDesc = &pElemDesc->tdesc;
4959 while (TRUE)
4960 {
4961 switch (pTypeDesc->vt)
4962 {
4963 case VT_USERDEFINED:
4964 pTypeDesc->u.hreftype += hrefoffset;
4965 return;
4966 case VT_PTR:
4967 case VT_SAFEARRAY:
4968 pTypeDesc = pTypeDesc->u.lptdesc;
4969 break;
4970 case VT_CARRAY:
4971 pTypeDesc = &pTypeDesc->u.lpadesc->tdescElem;
4972 break;
4973 default:
4974 return;
4975 }
4976 }
4977 }
4978
4979 static inline void ITypeInfoImpl_FuncDescAddHrefOffset( LPFUNCDESC pFuncDesc, UINT hrefoffset)
4980 {
4981 SHORT i;
4982 for (i = 0; i < pFuncDesc->cParams; i++)
4983 ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->lprgelemdescParam[i], hrefoffset);
4984 ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->elemdescFunc, hrefoffset);
4985 }
4986
4987 /* ITypeInfo::GetFuncDesc
4988 *
4989 * Retrieves the FUNCDESC structure that contains information about a
4990 * specified function.
4991 *
4992 */
4993 static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( ITypeInfo2 *iface, UINT index,
4994 LPFUNCDESC *ppFuncDesc)
4995 {
4996 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4997 const FUNCDESC *internal_funcdesc;
4998 HRESULT hr;
4999 UINT hrefoffset = 0;
5000
5001 TRACE("(%p) index %d\n", This, index);
5002
5003 if (This->TypeAttr.typekind == TKIND_DISPATCH)
5004 hr = ITypeInfoImpl_GetInternalDispatchFuncDesc((ITypeInfo *)iface, index,
5005 &internal_funcdesc, NULL,
5006 &hrefoffset);
5007 else
5008 hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, index,
5009 &internal_funcdesc);
5010 if (FAILED(hr))
5011 {
5012 WARN("description for function %d not found\n", index);
5013 return hr;
5014 }
5015
5016 hr = TLB_AllocAndInitFuncDesc(
5017 internal_funcdesc,
5018 ppFuncDesc,
5019 This->TypeAttr.typekind == TKIND_DISPATCH);
5020
5021 if ((This->TypeAttr.typekind == TKIND_DISPATCH) && hrefoffset)
5022 ITypeInfoImpl_FuncDescAddHrefOffset(*ppFuncDesc, hrefoffset);
5023
5024 TRACE("-- 0x%08x\n", hr);
5025 return hr;
5026 }
5027
5028 static HRESULT TLB_AllocAndInitVarDesc( const VARDESC *src, VARDESC **dest_ptr )
5029 {
5030 VARDESC *dest;
5031 char *buffer;
5032 SIZE_T size = sizeof(*src);
5033 HRESULT hr;
5034
5035 if (src->lpstrSchema) size += (strlenW(src->lpstrSchema) + 1) * sizeof(WCHAR);
5036 if (src->varkind == VAR_CONST)
5037 size += sizeof(VARIANT);
5038 size += TLB_SizeElemDesc(&src->elemdescVar);
5039
5040 dest = (VARDESC *)SysAllocStringByteLen(NULL, size);
5041 if (!dest) return E_OUTOFMEMORY;
5042
5043 *dest = *src;
5044 buffer = (char *)(dest + 1);
5045 if (src->lpstrSchema)
5046 {
5047 int len;
5048 dest->lpstrSchema = (LPOLESTR)buffer;
5049 len = strlenW(src->lpstrSchema);
5050 memcpy(dest->lpstrSchema, src->lpstrSchema, (len + 1) * sizeof(WCHAR));
5051 buffer += (len + 1) * sizeof(WCHAR);
5052 }
5053
5054 if (src->varkind == VAR_CONST)
5055 {
5056 HRESULT hr;
5057
5058 dest->u.lpvarValue = (VARIANT *)buffer;
5059 *dest->u.lpvarValue = *src->u.lpvarValue;
5060 buffer += sizeof(VARIANT);
5061 VariantInit(dest->u.lpvarValue);
5062 hr = VariantCopy(dest->u.lpvarValue, src->u.lpvarValue);
5063 if (FAILED(hr))
5064 {
5065 SysFreeString((BSTR)dest_ptr);
5066 return hr;
5067 }
5068 }
5069 hr = TLB_CopyElemDesc(&src->elemdescVar, &dest->elemdescVar, &buffer);
5070 if (FAILED(hr))
5071 {
5072 if (src->varkind == VAR_CONST)
5073 VariantClear(dest->u.lpvarValue);
5074 SysFreeString((BSTR)dest);
5075 return hr;
5076 }
5077 *dest_ptr = dest;
5078 return S_OK;
5079 }
5080
5081 /* ITypeInfo::GetVarDesc
5082 *
5083 * Retrieves a VARDESC structure that describes the specified variable.
5084 *
5085 */
5086 static HRESULT WINAPI ITypeInfo_fnGetVarDesc( ITypeInfo2 *iface, UINT index,
5087 LPVARDESC *ppVarDesc)
5088 {
5089 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5090 int i;
5091 const TLBVarDesc *pVDesc;
5092
5093 TRACE("(%p) index %d\n", This, index);
5094
5095 for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next)
5096 ;
5097
5098 if (pVDesc)
5099 return TLB_AllocAndInitVarDesc(&pVDesc->vardesc, ppVarDesc);
5100
5101 return E_INVALIDARG;
5102 }
5103
5104 /* ITypeInfo_GetNames
5105 *
5106 * Retrieves the variable with the specified member ID (or the name of the
5107 * property or method and its parameters) that correspond to the specified
5108 * function ID.
5109 */
5110 static HRESULT WINAPI ITypeInfo_fnGetNames( ITypeInfo2 *iface, MEMBERID memid,
5111 BSTR *rgBstrNames, UINT cMaxNames, UINT *pcNames)
5112 {
5113 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5114 const TLBFuncDesc *pFDesc;
5115 const TLBVarDesc *pVDesc;
5116 int i;
5117 TRACE("(%p) memid=0x%08x Maxname=%d\n", This, memid, cMaxNames);
5118 for(pFDesc=This->funclist; pFDesc && pFDesc->funcdesc.memid != memid; pFDesc=pFDesc->next);
5119 if(pFDesc)
5120 {
5121 /* function found, now return function and parameter names */
5122 for(i=0; i<cMaxNames && i <= pFDesc->funcdesc.cParams; i++)
5123 {
5124 if(!i)
5125 *rgBstrNames=SysAllocString(pFDesc->Name);
5126 else
5127 rgBstrNames[i]=SysAllocString(pFDesc->pParamDesc[i-1].Name);
5128 }
5129 *pcNames=i;
5130 }
5131 else
5132 {
5133 for(pVDesc=This->varlist; pVDesc && pVDesc->vardesc.memid != memid; pVDesc=pVDesc->next);
5134 if(pVDesc)
5135 {
5136 *rgBstrNames=SysAllocString(pVDesc->Name);
5137 *pcNames=1;
5138 }
5139 else
5140 {
5141 if(This->impltypelist &&
5142 (This->TypeAttr.typekind==TKIND_INTERFACE || This->TypeAttr.typekind==TKIND_DISPATCH)) {
5143 /* recursive search */
5144 ITypeInfo *pTInfo;
5145 HRESULT result;
5146 result=ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef,
5147 &pTInfo);
5148 if(SUCCEEDED(result))
5149 {
5150 result=ITypeInfo_GetNames(pTInfo, memid, rgBstrNames, cMaxNames, pcNames);
5151 ITypeInfo_Release(pTInfo);
5152 return result;
5153 }
5154 WARN("Could not search inherited interface!\n");
5155 }
5156 else
5157 {
5158 WARN("no names found\n");
5159 }
5160 *pcNames=0;
5161 return TYPE_E_ELEMENTNOTFOUND;
5162 }
5163 }
5164 return S_OK;
5165 }
5166
5167
5168 /* ITypeInfo::GetRefTypeOfImplType
5169 *
5170 * If a type description describes a COM class, it retrieves the type
5171 * description of the implemented interface types. For an interface,
5172 * GetRefTypeOfImplType returns the type information for inherited interfaces,
5173 * if any exist.
5174 *
5175 */
5176 static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType(
5177 ITypeInfo2 *iface,
5178 UINT index,
5179 HREFTYPE *pRefType)
5180 {
5181 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5182 int i;
5183 HRESULT hr = S_OK;
5184 const TLBImplType *pImpl = This->impltypelist;
5185
5186 TRACE("(%p) index %d\n", This, index);
5187 if (TRACE_ON(ole)) dump_TypeInfo(This);
5188
5189 if(index==(UINT)-1)
5190 {
5191 /* only valid on dual interfaces;
5192 retrieve the associated TKIND_INTERFACE handle for the current TKIND_DISPATCH
5193 */
5194 if( This->TypeAttr.typekind != TKIND_DISPATCH) return E_INVALIDARG;
5195
5196 if (This->TypeAttr.wTypeFlags & TYPEFLAG_FDISPATCHABLE &&
5197 This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL )
5198 {
5199 *pRefType = -1;
5200 }
5201 else
5202 {
5203 hr = TYPE_E_ELEMENTNOTFOUND;
5204 }
5205 }
5206 else if(index == 0 && This->TypeAttr.typekind == TKIND_DISPATCH)
5207 {
5208 /* All TKIND_DISPATCHs are made to look like they inherit from IDispatch */
5209 *pRefType = This->pTypeLib->dispatch_href;
5210 }
5211 else
5212 {
5213 /* get element n from linked list */
5214 for(i=0; pImpl && i<index; i++)
5215 {
5216 pImpl = pImpl->next;
5217 }
5218
5219 if (pImpl)
5220 *pRefType = pImpl->hRef;
5221 else
5222 hr = TYPE_E_ELEMENTNOTFOUND;
5223 }
5224
5225 if(TRACE_ON(ole))
5226 {
5227 if(SUCCEEDED(hr))
5228 TRACE("SUCCESS -- hRef = 0x%08x\n", *pRefType );
5229 else
5230 TRACE("FAILURE -- hresult = 0x%08x\n", hr);
5231 }
5232
5233 return hr;
5234 }
5235
5236 /* ITypeInfo::GetImplTypeFlags
5237 *
5238 * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface
5239 * or base interface in a type description.
5240 */
5241 static HRESULT WINAPI ITypeInfo_fnGetImplTypeFlags( ITypeInfo2 *iface,
5242 UINT index, INT *pImplTypeFlags)
5243 {
5244 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5245 int i;
5246 TLBImplType *pImpl;
5247
5248 TRACE("(%p) index %d\n", This, index);
5249 for(i=0, pImpl=This->impltypelist; i<index && pImpl;
5250 i++, pImpl=pImpl->next)
5251 ;
5252 if(i==index && pImpl){
5253 *pImplTypeFlags=pImpl->implflags;
5254 return S_OK;
5255 }
5256 *pImplTypeFlags=0;
5257 return TYPE_E_ELEMENTNOTFOUND;
5258 }
5259
5260 /* GetIDsOfNames
5261 * Maps between member names and member IDs, and parameter names and
5262 * parameter IDs.
5263 */
5264 static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( ITypeInfo2 *iface,
5265 LPOLESTR *rgszNames, UINT cNames, MEMBERID *pMemId)
5266 {
5267 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5268 const TLBFuncDesc *pFDesc;
5269 const TLBVarDesc *pVDesc;
5270 HRESULT ret=S_OK;
5271 int i;
5272
5273 TRACE("(%p) Name %s cNames %d\n", This, debugstr_w(*rgszNames),
5274 cNames);
5275
5276 /* init out parameters in case of failure */
5277 for (i = 0; i < cNames; i++)
5278 pMemId[i] = MEMBERID_NIL;
5279
5280 for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next) {
5281 int j;
5282 if(!lstrcmpiW(*rgszNames, pFDesc->Name)) {
5283 if(cNames) *pMemId=pFDesc->funcdesc.memid;
5284 for(i=1; i < cNames; i++){
5285 for(j=0; j<pFDesc->funcdesc.cParams; j++)
5286 if(!lstrcmpiW(rgszNames[i],pFDesc->pParamDesc[j].Name))
5287 break;
5288 if( j<pFDesc->funcdesc.cParams)
5289 pMemId[i]=j;
5290 else
5291 ret=DISP_E_UNKNOWNNAME;
5292 };
5293 TRACE("-- 0x%08x\n", ret);
5294 return ret;
5295 }
5296 }
5297 for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
5298 if(!lstrcmpiW(*rgszNames, pVDesc->Name)) {
5299 if(cNames) *pMemId=pVDesc->vardesc.memid;
5300 return ret;
5301 }
5302 }
5303 /* not found, see if it can be found in an inherited interface */
5304 if(This->impltypelist) {
5305 /* recursive search */
5306 ITypeInfo *pTInfo;
5307 ret=ITypeInfo_GetRefTypeInfo(iface,
5308 This->impltypelist->hRef, &pTInfo);
5309 if(SUCCEEDED(ret)){
5310 ret=ITypeInfo_GetIDsOfNames(pTInfo, rgszNames, cNames, pMemId );
5311 ITypeInfo_Release(pTInfo);
5312 return ret;
5313 }
5314 WARN("Could not search inherited interface!\n");
5315 } else
5316 WARN("no names found\n");
5317 return DISP_E_UNKNOWNNAME;
5318 }
5319
5320 /* ITypeInfo::Invoke
5321 *
5322 * Invokes a method, or accesses a property of an object, that implements the
5323 * interface described by the type description.
5324 */
5325 DWORD
5326 _invoke(FARPROC func,CALLCONV callconv, int nrargs, DWORD *args) {
5327 DWORD res;
5328
5329 if (TRACE_ON(ole)) {
5330 int i;
5331 TRACE("Calling %p(",func);
5332 for (i=0;i<nrargs;i++) TRACE("%08x,",args[i]);
5333 TRACE(")\n");
5334 }
5335
5336 switch (callconv) {
5337 case CC_STDCALL:
5338
5339 switch (nrargs) {
5340 case 0:
5341 res = func();
5342 break;
5343 case 1:
5344 res = func(args[0]);
5345 break;
5346 case 2:
5347 res = func(args[0],args[1]);
5348 break;
5349 case 3:
5350 res = func(args[0],args[1],args[2]);
5351 break;
5352 case 4:
5353 res = func(args[0],args[1],args[2],args[3]);
5354 break;
5355 case 5:
5356 res = func(args[0],args[1],args[2],args[3],args[4]);
5357 break;
5358 case 6:
5359 res = func(args[0],args[1],args[2],args[3],args[4],args[5]);
5360 break;
5361 case 7:
5362 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
5363 break;
5364 case 8:
5365 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
5366 break;
5367 case 9:
5368 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]);
5369 break;
5370 case 10:
5371 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9]);
5372 break;
5373 case 11:
5374 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]);
5375 break;
5376 case 12:
5377 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11]);
5378 break;
5379 case 13:
5380 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12]);
5381 break;
5382 case 14:
5383 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13]);
5384 break;
5385 case 15:
5386 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14]);
5387 break;
5388 case 16:
5389 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15]);
5390 break;
5391 case 17:
5392 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16]);
5393 break;
5394 case 18:
5395 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17]);
5396 break;
5397 case 19:
5398 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18]);
5399 break;
5400 case 20:
5401 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19]);
5402 break;
5403 case 21:
5404 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20]);
5405 break;
5406 case 22:
5407 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21]);
5408 break;
5409 case 23:
5410 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22]);
5411 break;
5412 case 24:
5413 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23]);
5414 break;
5415 case 25:
5416 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24]);
5417 break;
5418 case 26:
5419 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24],args[25]);
5420 break;
5421 case 27:
5422 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24],args[25],args[26]);
5423 break;
5424 case 28:
5425 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24],args[25],args[26],args[27]);
5426 break;
5427 case 29:
5428 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24],args[25],args[26],args[27],args[28]);
5429 break;
5430 case 30:
5431 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24],args[25],args[26],args[27],args[28],args[29]);
5432 break;
5433 default:
5434 FIXME("unsupported number of arguments %d in stdcall\n",nrargs);
5435 res = -1;
5436 break;
5437 }
5438 break;
5439 default:
5440 FIXME("unsupported calling convention %d\n",callconv);
5441 res = -1;
5442 break;
5443 }
5444 TRACE("returns %08x\n",res);
5445 return res;
5446 }
5447
5448 extern int _argsize(DWORD vt);
5449
5450 static HRESULT userdefined_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
5451 {
5452 HRESULT hr = S_OK;
5453 ITypeInfo *tinfo2 = NULL;
5454 TYPEATTR *tattr = NULL;
5455
5456 hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2);
5457 if (hr)
5458 {
5459 ERR("Could not get typeinfo of hreftype %x for VT_USERDEFINED, "
5460 "hr = 0x%08x\n",
5461 tdesc->u.hreftype, hr);
5462 return hr;
5463 }
5464 hr = ITypeInfo_GetTypeAttr(tinfo2, &tattr);
5465 if (hr)
5466 {
5467 ERR("ITypeInfo_GetTypeAttr failed, hr = 0x%08x\n", hr);
5468 ITypeInfo_Release(tinfo2);
5469 return hr;
5470 }
5471
5472 switch (tattr->typekind)
5473 {
5474 case TKIND_ENUM:
5475 *vt |= VT_I4;
5476 break;
5477
5478 case TKIND_ALIAS:
5479 tdesc = &tattr->tdescAlias;
5480 hr = typedescvt_to_variantvt(tinfo2, &tattr->tdescAlias, vt);
5481 break;
5482
5483 case TKIND_INTERFACE:
5484 if (tattr->wTypeFlags & TYPEFLAG_FDISPATCHABLE)
5485 *vt |= VT_DISPATCH;
5486 else
5487 *vt |= VT_UNKNOWN;
5488 break;
5489
5490 case TKIND_DISPATCH:
5491 *vt |= VT_DISPATCH;
5492 break;
5493
5494 case TKIND_COCLASS:
5495 *vt |= VT_DISPATCH;
5496 break;
5497
5498 case TKIND_RECORD:
5499 FIXME("TKIND_RECORD unhandled.\n");
5500 hr = E_NOTIMPL;
5501 break;
5502
5503 case TKIND_UNION:
5504 FIXME("TKIND_UNION unhandled.\n");
5505 hr = E_NOTIMPL;
5506 break;
5507
5508 default:
5509 FIXME("TKIND %d unhandled.\n",tattr->typekind);
5510 hr = E_NOTIMPL;
5511 break;
5512 }
5513 ITypeInfo_ReleaseTypeAttr(tinfo2, tattr);
5514 ITypeInfo_Release(tinfo2);
5515 return hr;
5516 }
5517
5518 static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
5519 {
5520 HRESULT hr = S_OK;
5521
5522 /* enforce only one level of pointer indirection */
5523 if (!(*vt & VT_BYREF) && !(*vt & VT_ARRAY) && (tdesc->vt == VT_PTR))
5524 {
5525 tdesc = tdesc->u.lptdesc;
5526
5527 /* munch VT_PTR -> VT_USERDEFINED(interface) into VT_UNKNOWN or
5528 * VT_DISPATCH and VT_PTR -> VT_PTR -> VT_USERDEFINED(interface) into
5529 * VT_BYREF|VT_DISPATCH or VT_BYREF|VT_UNKNOWN */
5530 if ((tdesc->vt == VT_USERDEFINED) ||
5531 ((tdesc->vt == VT_PTR) && (tdesc->u.lptdesc->vt == VT_USERDEFINED)))
5532 {
5533 VARTYPE vt_userdefined = 0;
5534 const TYPEDESC *tdesc_userdefined = tdesc;
5535 if (tdesc->vt == VT_PTR)
5536 {
5537 vt_userdefined = VT_BYREF;
5538 tdesc_userdefined = tdesc->u.lptdesc;
5539 }
5540 hr = userdefined_to_variantvt(tinfo, tdesc_userdefined, &vt_userdefined);
5541 if ((hr == S_OK) &&
5542 (((vt_userdefined & VT_TYPEMASK) == VT_UNKNOWN) ||
5543 ((vt_userdefined & VT_TYPEMASK) == VT_DISPATCH)))
5544 {
5545 *vt |= vt_userdefined;
5546 return S_OK;
5547 }
5548 }
5549 *vt = VT_BYREF;
5550 }
5551
5552 switch (tdesc->vt)
5553 {
5554 case VT_HRESULT:
5555 *vt |= VT_ERROR;
5556 break;
5557 case VT_USERDEFINED:
5558 hr = userdefined_to_variantvt(tinfo, tdesc, vt);
5559 break;
5560 case VT_VOID:
5561 case VT_CARRAY:
5562 case VT_PTR:
5563 case VT_LPSTR:
5564 case VT_LPWSTR:
5565 ERR("cannot convert type %d into variant VT\n", tdesc->vt);
5566 hr = DISP_E_BADVARTYPE;
5567 break;
5568 case VT_SAFEARRAY:
5569 *vt |= VT_ARRAY;
5570 hr = typedescvt_to_variantvt(tinfo, tdesc->u.lptdesc, vt);
5571 break;
5572 default:
5573 *vt |= tdesc->vt;
5574 break;
5575 }
5576 return hr;
5577 }
5578
5579 /***********************************************************************
5580 * DispCallFunc (OLEAUT32.@)
5581 *
5582 * Invokes a function of the specified calling convention, passing the
5583 * specified arguments and returns the result.
5584 *
5585 * PARAMS
5586 * pvInstance [I] Optional pointer to the instance whose function to invoke.
5587 * oVft [I] The offset in the vtable. See notes.
5588 * cc [I] Calling convention of the function to call.
5589 * vtReturn [I] The return type of the function.
5590 * cActuals [I] Number of parameters.
5591 * prgvt [I] The types of the parameters to pass. This is used for sizing only.
5592 * prgpvarg [I] The arguments to pass.
5593 * pvargResult [O] The return value of the function. Can be NULL.
5594 *
5595 * RETURNS
5596 * Success: S_OK.
5597 * Failure: HRESULT code.
5598 *
5599 * NOTES
5600 * The HRESULT return value of this function is not affected by the return
5601 * value of the user supplied function, which is returned in pvargResult.
5602 *
5603 * If pvInstance is NULL then a non-object function is to be called and oVft
5604 * is the address of the function to call.
5605 *
5606 * The cc parameter can be one of the following values:
5607 *|CC_FASTCALL
5608 *|CC_CDECL
5609 *|CC_PASCAL
5610 *|CC_STDCALL
5611 *|CC_FPFASTCALL
5612 *|CC_SYSCALL
5613 *|CC_MPWCDECL
5614 *|CC_MPWPASCAL
5615 *
5616 */
5617 HRESULT WINAPI
5618 DispCallFunc(
5619 void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, UINT cActuals,
5620 VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult)
5621 {
5622 int i, argsize, argspos;
5623 DWORD *args;
5624 HRESULT hres;
5625
5626 TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
5627 pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg,
5628 pvargResult, V_VT(pvargResult));
5629
5630 argsize = 0;
5631 if (pvInstance)
5632 argsize++; /* for This pointer */
5633
5634 for (i=0;i<cActuals;i++)
5635 {
5636 TRACE("arg %d: type %d, size %d\n",i,prgvt[i],_argsize(prgvt[i]));
5637 dump_Variant(prgpvarg[i]);
5638 argsize += _argsize(prgvt[i]);
5639 }
5640 args = HeapAlloc(GetProcessHeap(),0,sizeof(DWORD)*argsize);
5641
5642 argspos = 0;
5643 if (pvInstance)
5644 {
5645 args[0] = (DWORD)pvInstance; /* the This pointer is always the first parameter */
5646 argspos++;
5647 }
5648
5649 for (i=0;i<cActuals;i++)
5650 {
5651 VARIANT *arg = prgpvarg[i];
5652 TRACE("Storing arg %d (%d as %d)\n",i,V_VT(arg),prgvt[i]);
5653 if (prgvt[i] == VT_VARIANT)
5654 memcpy(&args[argspos], arg, _argsize(prgvt[i]) * sizeof(DWORD));
5655 else
5656 memcpy(&args[argspos], &V_NONE(arg), _argsize(prgvt[i]) * sizeof(DWORD));
5657 argspos += _argsize(prgvt[i]);
5658 }
5659
5660 if (pvInstance)
5661 {
5662 FARPROC *vtable = *(FARPROC**)pvInstance;
5663 hres = _invoke(vtable[oVft/sizeof(void *)], cc, argsize, args);
5664 }
5665 else
5666 /* if we aren't invoking an object then the function pointer is stored
5667 * in oVft */
5668 hres = _invoke((FARPROC)oVft, cc, argsize, args);
5669
5670 if (pvargResult && (vtReturn != VT_EMPTY))
5671 {
5672 TRACE("Method returned 0x%08x\n",hres);
5673 V_VT(pvargResult) = vtReturn;
5674 V_UI4(pvargResult) = hres;
5675 }
5676
5677 HeapFree(GetProcessHeap(),0,args);
5678 return S_OK;
5679 }
5680
5681 #define INVBUF_ELEMENT_SIZE \
5682 (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *) + sizeof(VARTYPE))
5683 #define INVBUF_GET_ARG_ARRAY(buffer, params) \
5684 ((VARIANTARG *)(buffer))
5685 #define INVBUF_GET_MISSING_ARG_ARRAY(buffer, params) \
5686 ((VARIANTARG *)((char *)(buffer) + sizeof(VARIANTARG) * (params)))
5687 #define INVBUF_GET_ARG_PTR_ARRAY(buffer, params) \
5688 ((VARIANTARG **)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG)) * (params)))
5689 #define INVBUF_GET_ARG_TYPE_ARRAY(buffer, params) \
5690 ((VARTYPE *)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *)) * (params)))
5691
5692 static HRESULT WINAPI ITypeInfo_fnInvoke(
5693 ITypeInfo2 *iface,
5694 VOID *pIUnk,
5695 MEMBERID memid,
5696 UINT16 wFlags,
5697 DISPPARAMS *pDispParams,
5698 VARIANT *pVarResult,
5699 EXCEPINFO *pExcepInfo,
5700 UINT *pArgErr)
5701 {
5702 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5703 int i;
5704 unsigned int var_index;
5705 TYPEKIND type_kind;
5706 HRESULT hres;
5707 const TLBFuncDesc *pFuncInfo;
5708
5709 TRACE("(%p)(%p,id=%d,flags=0x%08x,%p,%p,%p,%p)\n",
5710 This,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr
5711 );
5712
5713 if (!pDispParams)
5714 {
5715 ERR("NULL pDispParams not allowed\n");
5716 return E_INVALIDARG;
5717 }
5718
5719 dump_DispParms(pDispParams);
5720
5721 if (pDispParams->cNamedArgs > pDispParams->cArgs)
5722 {
5723 ERR("named argument array cannot be bigger than argument array (%d/%d)\n",
5724 pDispParams->cNamedArgs, pDispParams->cArgs);
5725 return E_INVALIDARG;
5726 }
5727
5728 /* we do this instead of using GetFuncDesc since it will return a fake
5729 * FUNCDESC for dispinterfaces and we want the real function description */
5730 for (pFuncInfo = This->funclist; pFuncInfo; pFuncInfo=pFuncInfo->next)
5731 if ((memid == pFuncInfo->funcdesc.memid) &&
5732 (wFlags & pFuncInfo->funcdesc.invkind))
5733 break;
5734
5735 if (pFuncInfo) {
5736 const FUNCDESC *func_desc = &pFuncInfo->funcdesc;
5737
5738 if (TRACE_ON(ole))
5739 {
5740 TRACE("invoking:\n");
5741 dump_TLBFuncDescOne(pFuncInfo);
5742 }
5743
5744 switch (func_desc->funckind) {
5745 case FUNC_PUREVIRTUAL:
5746 case FUNC_VIRTUAL: {
5747 void *buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, INVBUF_ELEMENT_SIZE * func_desc->cParams);
5748 VARIANT varresult;
5749 VARIANT retval; /* pointer for storing byref retvals in */
5750 VARIANTARG **prgpvarg = INVBUF_GET_ARG_PTR_ARRAY(buffer, func_desc->cParams);
5751 VARIANTARG *rgvarg = INVBUF_GET_ARG_ARRAY(buffer, func_desc->cParams);
5752 VARTYPE *rgvt = INVBUF_GET_ARG_TYPE_ARRAY(buffer, func_desc->cParams);
5753 UINT cNamedArgs = pDispParams->cNamedArgs;
5754 DISPID *rgdispidNamedArgs = pDispParams->rgdispidNamedArgs;
5755
5756 hres = S_OK;
5757
5758 if (func_desc->invkind & (INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF))
5759 {
5760 if (!cNamedArgs || (rgdispidNamedArgs[0] != DISPID_PROPERTYPUT))
5761 {
5762 ERR("first named arg for property put invocation must be DISPID_PROPERTYPUT\n");
5763 hres = DISP_E_PARAMNOTFOUND;
5764 goto func_fail;
5765 }
5766 /* ignore the DISPID_PROPERTYPUT named argument from now on */
5767 cNamedArgs--;
5768 rgdispidNamedArgs++;
5769 }
5770
5771 if (func_desc->cParamsOpt < 0 && cNamedArgs)
5772 {
5773 ERR("functions with the vararg attribute do not support named arguments\n");
5774 hres = DISP_E_NONAMEDARGS;
5775 goto func_fail;
5776 }
5777
5778 for (i = 0; i < func_desc->cParams; i++)
5779 {
5780 TYPEDESC *tdesc = &func_desc->lprgelemdescParam[i].tdesc;
5781 hres = typedescvt_to_variantvt((ITypeInfo *)iface, tdesc, &rgvt[i]);
5782 if (FAILED(hres))
5783 goto func_fail;
5784 }
5785
5786 TRACE("changing args\n");
5787 for (i = 0; i < func_desc->cParams; i++)
5788 {
5789 USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
5790 VARIANTARG *src_arg;
5791
5792 if (cNamedArgs)
5793 {
5794 USHORT j;
5795 src_arg = NULL;
5796 for (j = 0; j < cNamedArgs; j++)
5797 if (rgdispidNamedArgs[j] == i)
5798 {
5799 src_arg = &pDispParams->rgvarg[j];
5800 break;
5801 }
5802 }
5803 else
5804 src_arg = i < pDispParams->cArgs ? &pDispParams->rgvarg[pDispParams->cArgs - 1 - i] : NULL;
5805
5806 if (wParamFlags & PARAMFLAG_FRETVAL)
5807 {
5808 /* under most conditions the caller is not allowed to
5809 * pass in a dispparam arg in the index of what would be
5810 * the retval parameter. however, there is an exception
5811 * where the extra parameter is used in an extra
5812 * IDispatch::Invoke below */
5813 if ((i < pDispParams->cArgs) &&
5814 ((func_desc->cParams != 1) || !pVarResult ||
5815 !(func_desc->invkind & INVOKE_PROPERTYGET)))
5816 {
5817 hres = DISP_E_BADPARAMCOUNT;
5818 break;
5819 }
5820
5821 /* note: this check is placed so that if the caller passes
5822 * in a VARIANTARG for the retval we just ignore it, like
5823 * native does */
5824 if (i == func_desc->cParams - 1)
5825 {
5826 VARIANTARG *arg;
5827 arg = prgpvarg[i] = &rgvarg[i];
5828 memset(arg, 0, sizeof(*arg));
5829 V_VT(arg) = rgvt[i];
5830 memset(&retval, 0, sizeof(retval));
5831 V_BYREF(arg) = &retval;
5832 }
5833 else
5834 {
5835 ERR("[retval] parameter must be the last parameter of the method (%d/%d)\n", i, func_desc->cParams);
5836 hres = E_UNEXPECTED;
5837 break;
5838 }
5839 }
5840 else if (src_arg)
5841 {
5842 dump_Variant(src_arg);
5843
5844 if (rgvt[i] == VT_VARIANT)
5845 hres = VariantCopy(&rgvarg[i], src_arg);
5846 else if (rgvt[i] == (VT_VARIANT | VT_BYREF))
5847 {
5848 if (rgvt[i] == V_VT(src_arg))
5849 V_VARIANTREF(&rgvarg[i]) = V_VARIANTREF(src_arg);
5850 else
5851 {
5852 VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
5853 hres = VariantCopy(&missing_arg[i], src_arg);
5854 V_VARIANTREF(&rgvarg[i]) = &missing_arg[i];
5855 }
5856 V_VT(&rgvarg[i]) = rgvt[i];
5857 }
5858 else if (rgvt[i] == (VT_VARIANT | VT_ARRAY) && func_desc->cParamsOpt < 0 && i == func_desc->cParams-1)
5859 {
5860 SAFEARRAY *a;
5861 SAFEARRAYBOUND bound;
5862 VARIANT *v;
5863 LONG j;
5864 bound.lLbound = 0;
5865 bound.cElements = pDispParams->cArgs-i;
5866 if (!(a = SafeArrayCreate(VT_VARIANT, 1, &bound)))
5867 {
5868 ERR("SafeArrayCreate failed\n");
5869 break;
5870 }
5871 hres = SafeArrayAccessData(a, (LPVOID)&v);
5872 if (hres != S_OK)
5873 {
5874 ERR("SafeArrayAccessData failed with %x\n", hres);
5875 break;
5876 }
5877 for (j = 0; j < bound.cElements; j++)
5878 VariantCopy(&v[j], &pDispParams->rgvarg[pDispParams->cArgs - 1 - i - j]);
5879 hres = SafeArrayUnaccessData(a);
5880 if (hres != S_OK)
5881 {
5882 ERR("SafeArrayUnaccessData failed with %x\n", hres);
5883 break;
5884 }
5885 V_ARRAY(&rgvarg[i]) = a;
5886 V_VT(&rgvarg[i]) = rgvt[i];
5887 }
5888 else if ((rgvt[i] & VT_BYREF) && !V_ISBYREF(src_arg))
5889 {
5890 VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
5891 V_VT(&missing_arg[i]) = V_VT(src_arg);
5892 hres = VariantChangeType(&missing_arg[i], src_arg, 0, rgvt[i] & ~VT_BYREF);
5893 V_BYREF(&rgvarg[i]) = &V_NONE(&missing_arg[i]);
5894 V_VT(&rgvarg[i]) = rgvt[i];
5895 }
5896 else if ((rgvt[i] & VT_BYREF) && (rgvt[i] == V_VT(src_arg)))
5897 {
5898 V_BYREF(&rgvarg[i]) = V_BYREF(src_arg);
5899 V_VT(&rgvarg[i]) = rgvt[i];
5900 }
5901 else
5902 {
5903 /* FIXME: this doesn't work for VT_BYREF arguments if
5904 * they are not the same type as in the paramdesc */
5905 V_VT(&rgvarg[i]) = V_VT(src_arg);
5906 hres = VariantChangeType(&rgvarg[i], src_arg, 0, rgvt[i]);
5907 V_VT(&rgvarg[i]) = rgvt[i];
5908 }
5909
5910 if (FAILED(hres))
5911 {
5912 ERR("failed to convert param %d to %s%s from %s%s\n", i,
5913 debugstr_vt(rgvt[i]), debugstr_vf(rgvt[i]),
5914 debugstr_VT(src_arg), debugstr_VF(src_arg));
5915 break;
5916 }
5917 prgpvarg[i] = &rgvarg[i];
5918 }
5919 else if (wParamFlags & PARAMFLAG_FOPT)
5920 {
5921 VARIANTARG *arg;
5922 arg = prgpvarg[i] = &rgvarg[i];
5923 if (wParamFlags & PARAMFLAG_FHASDEFAULT)
5924 {
5925 hres = VariantCopy(arg, &func_desc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
5926 if (FAILED(hres))
5927 break;
5928 }
5929 else
5930 {
5931 VARIANTARG *missing_arg;
5932 /* if the function wants a pointer to a variant then
5933 * set that up, otherwise just pass the VT_ERROR in
5934 * the argument by value */
5935 if (rgvt[i] & VT_BYREF)
5936 {
5937 missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams) + i;
5938 V_VT(arg) = VT_VARIANT | VT_BYREF;
5939 V_VARIANTREF(arg) = missing_arg;
5940 }
5941 else
5942 missing_arg = arg;
5943 V_VT(missing_arg) = VT_ERROR;
5944 V_ERROR(missing_arg) = DISP_E_PARAMNOTFOUND;
5945 }
5946 }
5947 else
5948 {
5949 hres = DISP_E_BADPARAMCOUNT;
5950 break;
5951 }
5952 }
5953 if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
5954
5955 /* VT_VOID is a special case for return types, so it is not
5956 * handled in the general function */
5957 if (func_desc->elemdescFunc.tdesc.vt == VT_VOID)
5958 V_VT(&varresult) = VT_EMPTY;
5959 else
5960 {
5961 V_VT(&varresult) = 0;
5962 hres = typedescvt_to_variantvt((ITypeInfo *)iface, &func_desc->elemdescFunc.tdesc, &V_VT(&varresult));
5963 if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
5964 }
5965
5966 hres = DispCallFunc(pIUnk, func_desc->oVft, func_desc->callconv,
5967 V_VT(&varresult), func_desc->cParams, rgvt,
5968 prgpvarg, &varresult);
5969
5970 for (i = 0; i < func_desc->cParams; i++)
5971 {
5972 USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
5973 if (wParamFlags & PARAMFLAG_FRETVAL)
5974 {
5975 if (TRACE_ON(ole))
5976 {
5977 TRACE("[retval] value: ");
5978 dump_Variant(prgpvarg[i]);
5979 }
5980
5981 if (pVarResult)
5982 {
5983 VariantInit(pVarResult);
5984 /* deref return value */
5985 hres = VariantCopyInd(pVarResult, prgpvarg[i]);
5986 }
5987
5988 /* free data stored in varresult. Note that
5989 * VariantClear doesn't do what we want because we are
5990 * working with byref types. */
5991 /* FIXME: clear safearrays, bstrs, records and
5992 * variants here too */
5993 if ((V_VT(prgpvarg[i]) == (VT_UNKNOWN | VT_BYREF)) ||
5994 (V_VT(prgpvarg[i]) == (VT_DISPATCH | VT_BYREF)))
5995 {
5996 if(*V_UNKNOWNREF(prgpvarg[i]))
5997 IUnknown_Release(*V_UNKNOWNREF(prgpvarg[i]));
5998 }
5999 break;
6000 }
6001 else if (i < pDispParams->cArgs)
6002 {
6003 if (wParamFlags & PARAMFLAG_FOUT)
6004 {
6005 VARIANTARG *arg = &pDispParams->rgvarg[pDispParams->cArgs - 1 - i];
6006
6007 if ((rgvt[i] == VT_BYREF) && (V_VT(arg) != VT_BYREF))
6008 hres = VariantChangeType(arg, &rgvarg[i], 0, V_VT(arg));
6009
6010 if (FAILED(hres))
6011 {
6012 ERR("failed to convert param %d to vt %d\n", i,
6013 V_VT(&pDispParams->rgvarg[pDispParams->cArgs - 1 - i]));
6014 break;
6015 }
6016 }
6017 else if (V_VT(prgpvarg[i]) == (VT_VARIANT | VT_ARRAY) &&
6018 func_desc->cParamsOpt < 0 &&
6019 i == func_desc->cParams-1)
6020 {
6021 SAFEARRAY *a = V_ARRAY(prgpvarg[i]);
6022 LONG j, ubound;
6023 VARIANT *v;
6024 hres = SafeArrayGetUBound(a, 1, &ubound);
6025 if (hres != S_OK)
6026 {
6027 ERR("SafeArrayGetUBound failed with %x\n", hres);
6028 break;
6029 }
6030 hres = SafeArrayAccessData(a, (LPVOID)&v);
6031 if (hres != S_OK)
6032 {
6033 ERR("SafeArrayAccessData failed with %x\n", hres);
6034 break;
6035 }
6036 for (j = 0; j <= ubound; j++)
6037 VariantClear(&v[j]);
6038 hres = SafeArrayUnaccessData(a);
6039 if (hres != S_OK)
6040 {
6041 ERR("SafeArrayUnaccessData failed with %x\n", hres);
6042 break;
6043 }
6044 }
6045 VariantClear(&rgvarg[i]);
6046 }
6047 else if (wParamFlags & PARAMFLAG_FOPT)
6048 {
6049 if (wParamFlags & PARAMFLAG_FHASDEFAULT)
6050 VariantClear(&rgvarg[i]);
6051 }
6052 }
6053
6054 if ((V_VT(&varresult) == VT_ERROR) && FAILED(V_ERROR(&varresult)))
6055 {
6056 WARN("invoked function failed with error 0x%08x\n", V_ERROR(&varresult));
6057 hres = DISP_E_EXCEPTION;
6058 if (pExcepInfo)
6059 {
6060 IErrorInfo *pErrorInfo;
6061 pExcepInfo->scode = V_ERROR(&varresult);
6062 if (GetErrorInfo(0, &pErrorInfo) == S_OK)
6063 {
6064 IErrorInfo_GetDescription(pErrorInfo, &pExcepInfo->bstrDescription);
6065 IErrorInfo_GetHelpFile(pErrorInfo, &pExcepInfo->bstrHelpFile);
6066 IErrorInfo_GetSource(pErrorInfo, &pExcepInfo->bstrSource);
6067 IErrorInfo_GetHelpContext(pErrorInfo, &pExcepInfo->dwHelpContext);
6068
6069 IErrorInfo_Release(pErrorInfo);
6070 }
6071 }
6072 }
6073 if (V_VT(&varresult) != VT_ERROR)
6074 {
6075 TRACE("varresult value: ");
6076 dump_Variant(&varresult);
6077
6078 if (pVarResult)
6079 {
6080 VariantClear(pVarResult);
6081 *pVarResult = varresult;
6082 }
6083 else
6084 VariantClear(&varresult);
6085 }
6086
6087 if (SUCCEEDED(hres) && pVarResult && (func_desc->cParams == 1) &&
6088 (func_desc->invkind & INVOKE_PROPERTYGET) &&
6089 (func_desc->lprgelemdescParam[0].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
6090 (pDispParams->cArgs != 0))
6091 {
6092 if (V_VT(pVarResult) == VT_DISPATCH)
6093 {
6094 IDispatch *pDispatch = V_DISPATCH(pVarResult);
6095 /* Note: not VariantClear; we still need the dispatch
6096 * pointer to be valid */
6097 VariantInit(pVarResult);
6098 hres = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL,
6099 GetSystemDefaultLCID(), INVOKE_PROPERTYGET,
6100 pDispParams, pVarResult, pExcepInfo, pArgErr);
6101 IDispatch_Release(pDispatch);
6102 }
6103 else
6104 {
6105 VariantClear(pVarResult);
6106 hres = DISP_E_NOTACOLLECTION;
6107 }
6108 }
6109
6110 func_fail:
6111 HeapFree(GetProcessHeap(), 0, buffer);
6112 break;
6113 }
6114 case FUNC_DISPATCH: {
6115 IDispatch *disp;
6116
6117 hres = IUnknown_QueryInterface((LPUNKNOWN)pIUnk,&IID_IDispatch,(LPVOID*)&disp);
6118 if (SUCCEEDED(hres)) {
6119 FIXME("Calling Invoke in IDispatch iface. untested!\n");
6120 hres = IDispatch_Invoke(
6121 disp,memid,&IID_NULL,LOCALE_USER_DEFAULT,wFlags,pDispParams,
6122 pVarResult,pExcepInfo,pArgErr
6123 );
6124 if (FAILED(hres))
6125 FIXME("IDispatch::Invoke failed with %08x. (Could be not a real error?)\n", hres);
6126 IDispatch_Release(disp);
6127 } else
6128 FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
6129 break;
6130 }
6131 default:
6132 FIXME("Unknown function invocation type %d\n", func_desc->funckind);
6133 hres = E_FAIL;
6134 break;
6135 }
6136
6137 TRACE("-- 0x%08x\n", hres);
6138 return hres;
6139
6140 } else if(SUCCEEDED(hres = ITypeInfo2_GetVarIndexOfMemId(iface, memid, &var_index))) {
6141 VARDESC *var_desc;
6142
6143 hres = ITypeInfo2_GetVarDesc(iface, var_index, &var_desc);
6144 if(FAILED(hres)) return hres;
6145
6146 FIXME("varseek: Found memid, but variable-based invoking not supported\n");
6147 dump_VARDESC(var_desc);
6148 ITypeInfo2_ReleaseVarDesc(iface, var_desc);
6149 return E_NOTIMPL;
6150 }
6151
6152 /* not found, look for it in inherited interfaces */
6153 ITypeInfo2_GetTypeKind(iface, &type_kind);
6154 if(type_kind == TKIND_INTERFACE || type_kind == TKIND_DISPATCH) {
6155 if(This->impltypelist) {
6156 /* recursive search */
6157 ITypeInfo *pTInfo;
6158 hres = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef, &pTInfo);
6159 if(SUCCEEDED(hres)){
6160 hres = ITypeInfo_Invoke(pTInfo,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr);
6161 ITypeInfo_Release(pTInfo);
6162 return hres;
6163 }
6164 WARN("Could not search inherited interface!\n");
6165 }
6166 }
6167 ERR("did not find member id %d, flags 0x%x!\n", memid, wFlags);
6168 return DISP_E_MEMBERNOTFOUND;
6169 }
6170
6171 /* ITypeInfo::GetDocumentation
6172 *
6173 * Retrieves the documentation string, the complete Help file name and path,
6174 * and the context ID for the Help topic for a specified type description.
6175 *
6176 * (Can be tested by the Visual Basic Editor in Word for instance.)
6177 */
6178 static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
6179 MEMBERID memid, BSTR *pBstrName, BSTR *pBstrDocString,
6180 DWORD *pdwHelpContext, BSTR *pBstrHelpFile)
6181 {
6182 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6183 const TLBFuncDesc *pFDesc;
6184 const TLBVarDesc *pVDesc;
6185 TRACE("(%p) memid %d Name(%p) DocString(%p)"
6186 " HelpContext(%p) HelpFile(%p)\n",
6187 This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
6188 if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
6189 if(pBstrName)
6190 *pBstrName=SysAllocString(This->Name);
6191 if(pBstrDocString)
6192 *pBstrDocString=SysAllocString(This->DocString);
6193 if(pdwHelpContext)
6194 *pdwHelpContext=This->dwHelpContext;
6195 if(pBstrHelpFile)
6196 *pBstrHelpFile=SysAllocString(This->DocString);/* FIXME */
6197 return S_OK;
6198 }else {/* for a member */
6199 for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
6200 if(pFDesc->funcdesc.memid==memid){
6201 if(pBstrName)
6202 *pBstrName = SysAllocString(pFDesc->Name);
6203 if(pBstrDocString)
6204 *pBstrDocString=SysAllocString(pFDesc->HelpString);
6205 if(pdwHelpContext)
6206 *pdwHelpContext=pFDesc->helpcontext;
6207 return S_OK;
6208 }
6209 for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
6210 if(pVDesc->vardesc.memid==memid){
6211 if(pBstrName)
6212 *pBstrName = SysAllocString(pVDesc->Name);
6213 if(pBstrDocString)
6214 *pBstrDocString=SysAllocString(pVDesc->HelpString);
6215 if(pdwHelpContext)
6216 *pdwHelpContext=pVDesc->HelpContext;
6217 return S_OK;
6218 }
6219 }
6220
6221 if(This->impltypelist &&
6222 (This->TypeAttr.typekind==TKIND_INTERFACE || This->TypeAttr.typekind==TKIND_DISPATCH)) {
6223 /* recursive search */
6224 ITypeInfo *pTInfo;
6225 HRESULT result;
6226 result = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef,
6227 &pTInfo);
6228 if(SUCCEEDED(result)) {
6229 result = ITypeInfo_GetDocumentation(pTInfo, memid, pBstrName,
6230 pBstrDocString, pdwHelpContext, pBstrHelpFile);
6231 ITypeInfo_Release(pTInfo);
6232 return result;
6233 }
6234 WARN("Could not search inherited interface!\n");
6235 }
6236
6237 WARN("member %d not found\n", memid);
6238 return TYPE_E_ELEMENTNOTFOUND;
6239 }
6240
6241 /* ITypeInfo::GetDllEntry
6242 *
6243 * Retrieves a description or specification of an entry point for a function
6244 * in a DLL.
6245 */
6246 static HRESULT WINAPI ITypeInfo_fnGetDllEntry( ITypeInfo2 *iface, MEMBERID memid,
6247 INVOKEKIND invKind, BSTR *pBstrDllName, BSTR *pBstrName,
6248 WORD *pwOrdinal)
6249 {
6250 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6251 const TLBFuncDesc *pFDesc;
6252
6253 TRACE("(%p)->(memid %x, %d, %p, %p, %p)\n", This, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
6254
6255 if (pBstrDllName) *pBstrDllName = NULL;
6256 if (pBstrName) *pBstrName = NULL;
6257 if (pwOrdinal) *pwOrdinal = 0;
6258
6259 if (This->TypeAttr.typekind != TKIND_MODULE)
6260 return TYPE_E_BADMODULEKIND;
6261
6262 for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
6263 if(pFDesc->funcdesc.memid==memid){
6264 dump_TypeInfo(This);
6265 if (TRACE_ON(ole))
6266 dump_TLBFuncDescOne(pFDesc);
6267
6268 if (pBstrDllName)
6269 *pBstrDllName = SysAllocString(This->DllName);
6270
6271 if (HIWORD(pFDesc->Entry) && (pFDesc->Entry != (void*)-1)) {
6272 if (pBstrName)
6273 *pBstrName = SysAllocString(pFDesc->Entry);
6274 if (pwOrdinal)
6275 *pwOrdinal = -1;
6276 return S_OK;
6277 }
6278 if (pBstrName)
6279 *pBstrName = NULL;
6280 if (pwOrdinal)
6281 *pwOrdinal = (DWORD)pFDesc->Entry;
6282 return S_OK;
6283 }
6284 return TYPE_E_ELEMENTNOTFOUND;
6285 }
6286
6287 /* internal function to make the inherited interfaces' methods appear
6288 * part of the interface */
6289 static HRESULT ITypeInfoImpl_GetDispatchRefTypeInfo( ITypeInfo *iface,
6290 HREFTYPE *hRefType, ITypeInfo **ppTInfo)
6291 {
6292 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6293 HRESULT hr;
6294
6295 TRACE("%p, 0x%x\n", iface, *hRefType);
6296
6297 if (This->impltypelist && (*hRefType & DISPATCH_HREF_MASK))
6298 {
6299 ITypeInfo *pSubTypeInfo;
6300
6301 hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef, &pSubTypeInfo);
6302 if (FAILED(hr))
6303 return hr;
6304
6305 hr = ITypeInfoImpl_GetDispatchRefTypeInfo(pSubTypeInfo,
6306 hRefType, ppTInfo);
6307 ITypeInfo_Release(pSubTypeInfo);
6308 if (SUCCEEDED(hr))
6309 return hr;
6310 }
6311 *hRefType -= DISPATCH_HREF_OFFSET;
6312
6313 if (!(*hRefType & DISPATCH_HREF_MASK))
6314 return ITypeInfo_GetRefTypeInfo(iface, *hRefType, ppTInfo);
6315 else
6316 return E_FAIL;
6317 }
6318
6319 /* ITypeInfo::GetRefTypeInfo
6320 *
6321 * If a type description references other type descriptions, it retrieves
6322 * the referenced type descriptions.
6323 */
6324 static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
6325 ITypeInfo2 *iface,
6326 HREFTYPE hRefType,
6327 ITypeInfo **ppTInfo)
6328 {
6329 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6330 HRESULT result = E_FAIL;
6331
6332 if ((This->hreftype != -1) && (This->hreftype == hRefType))
6333 {
6334 *ppTInfo = (ITypeInfo *)&This->lpVtbl;
6335 ITypeInfo_AddRef(*ppTInfo);
6336 result = S_OK;
6337 }
6338 else if (hRefType == -1 &&
6339 (This->TypeAttr.typekind == TKIND_DISPATCH) &&
6340 (This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL))
6341 {
6342 /* when we meet a DUAL dispinterface, we must create the interface
6343 * version of it.
6344 */
6345 ITypeInfoImpl* pTypeInfoImpl = (ITypeInfoImpl*) ITypeInfo_Constructor();
6346
6347
6348 /* the interface version contains the same information as the dispinterface
6349 * copy the contents of the structs.
6350 */
6351 *pTypeInfoImpl = *This;
6352 pTypeInfoImpl->ref = 0;
6353
6354 /* change the type to interface */
6355 pTypeInfoImpl->TypeAttr.typekind = TKIND_INTERFACE;
6356
6357 *ppTInfo = (ITypeInfo*) pTypeInfoImpl;
6358
6359 /* we use data structures from This, so we need to keep a reference
6360 * to it to stop it being destroyed and signal to the new instance to
6361 * not free its data structures when it is destroyed */
6362 pTypeInfoImpl->no_free_data = TRUE;
6363 pTypeInfoImpl->next = This;
6364 ITypeInfo_AddRef((ITypeInfo*) This);
6365
6366 ITypeInfo_AddRef(*ppTInfo);
6367
6368 result = S_OK;
6369
6370 } else if ((hRefType != -1) && (hRefType & DISPATCH_HREF_MASK) &&
6371 (This->TypeAttr.typekind == TKIND_DISPATCH) &&
6372 (This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL))
6373 {
6374 HREFTYPE href_dispatch = hRefType;
6375 result = ITypeInfoImpl_GetDispatchRefTypeInfo((ITypeInfo *)iface, &href_dispatch, ppTInfo);
6376 } else {
6377 TLBRefType *ref_type;
6378 LIST_FOR_EACH_ENTRY(ref_type, &This->pTypeLib->ref_list, TLBRefType, entry)
6379 {
6380 if(ref_type->reference == hRefType)
6381 break;
6382 }
6383 if(&ref_type->entry == &This->pTypeLib->ref_list)
6384 {
6385 FIXME("Can't find pRefType for ref %x\n", hRefType);
6386 goto end;
6387 }
6388 if(hRefType != -1) {
6389 ITypeLib *pTLib = NULL;
6390
6391 if(ref_type->pImpTLInfo == TLB_REF_INTERNAL) {
6392 UINT Index;
6393 result = ITypeInfo_GetContainingTypeLib(iface, &pTLib, &Index);
6394 } else {
6395 if(ref_type->pImpTLInfo->pImpTypeLib) {
6396 TRACE("typeinfo in imported typelib that is already loaded\n");
6397 pTLib = (ITypeLib*)ref_type->pImpTLInfo->pImpTypeLib;
6398 ITypeLib2_AddRef(pTLib);
6399 result = S_OK;
6400 } else {
6401 TRACE("typeinfo in imported typelib that isn't already loaded\n");
6402 result = LoadRegTypeLib( &ref_type->pImpTLInfo->guid,
6403 ref_type->pImpTLInfo->wVersionMajor,
6404 ref_type->pImpTLInfo->wVersionMinor,
6405 ref_type->pImpTLInfo->lcid,
6406 &pTLib);
6407
6408 if(!SUCCEEDED(result)) {
6409 BSTR libnam=SysAllocString(ref_type->pImpTLInfo->name);
6410 result=LoadTypeLib(libnam, &pTLib);
6411 SysFreeString(libnam);
6412 }
6413 if(SUCCEEDED(result)) {
6414 ref_type->pImpTLInfo->pImpTypeLib = (ITypeLibImpl*)pTLib;
6415 ITypeLib2_AddRef(pTLib);
6416 }
6417 }
6418 }
6419 if(SUCCEEDED(result)) {
6420 if(ref_type->index == TLB_REF_USE_GUID)
6421 result = ITypeLib2_GetTypeInfoOfGuid(pTLib,
6422 &ref_type->guid,
6423 ppTInfo);
6424 else
6425 result = ITypeLib2_GetTypeInfo(pTLib, ref_type->index,
6426 ppTInfo);
6427 }
6428 if (pTLib != NULL)
6429 ITypeLib2_Release(pTLib);
6430 }
6431 }
6432
6433 end:
6434 TRACE("(%p) hreftype 0x%04x loaded %s (%p)\n", This, hRefType,
6435 SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
6436 return result;
6437 }
6438
6439 /* ITypeInfo::AddressOfMember
6440 *
6441 * Retrieves the addresses of static functions or variables, such as those
6442 * defined in a DLL.
6443 */
6444 static HRESULT WINAPI ITypeInfo_fnAddressOfMember( ITypeInfo2 *iface,
6445 MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
6446 {
6447 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6448 HRESULT hr;
6449 BSTR dll, entry;
6450 WORD ordinal;
6451 HMODULE module;
6452
6453 TRACE("(%p)->(0x%x, 0x%x, %p)\n", This, memid, invKind, ppv);
6454
6455 hr = ITypeInfo_GetDllEntry(iface, memid, invKind, &dll, &entry, &ordinal);
6456 if (FAILED(hr))
6457 return hr;
6458
6459 module = LoadLibraryW(dll);
6460 if (!module)
6461 {
6462 ERR("couldn't load %s\n", debugstr_w(dll));
6463 SysFreeString(dll);
6464 if (entry) SysFreeString(entry);
6465 return STG_E_FILENOTFOUND;
6466 }
6467 /* FIXME: store library somewhere where we can free it */
6468
6469 if (entry)
6470 {
6471 LPSTR entryA;
6472 INT len = WideCharToMultiByte(CP_ACP, 0, entry, -1, NULL, 0, NULL, NULL);
6473 entryA = HeapAlloc(GetProcessHeap(), 0, len);
6474 WideCharToMultiByte(CP_ACP, 0, entry, -1, entryA, len, NULL, NULL);
6475
6476 *ppv = GetProcAddress(module, entryA);
6477 if (!*ppv)
6478 ERR("function not found %s\n", debugstr_a(entryA));
6479
6480 HeapFree(GetProcessHeap(), 0, entryA);
6481 }
6482 else
6483 {
6484 *ppv = GetProcAddress(module, MAKEINTRESOURCEA(ordinal));
6485 if (!*ppv)
6486 ERR("function not found %d\n", ordinal);
6487 }
6488
6489 SysFreeString(dll);
6490 if (entry) SysFreeString(entry);
6491
6492 if (!*ppv)
6493 return TYPE_E_DLLFUNCTIONNOTFOUND;
6494
6495 return S_OK;
6496 }
6497
6498 /* ITypeInfo::CreateInstance
6499 *
6500 * Creates a new instance of a type that describes a component object class
6501 * (coclass).
6502 */
6503 static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface,
6504 IUnknown *pOuterUnk, REFIID riid, VOID **ppvObj)
6505 {
6506 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6507 HRESULT hr;
6508 TYPEATTR *pTA;
6509
6510 TRACE("(%p)->(%p, %s, %p)\n", This, pOuterUnk, debugstr_guid(riid), ppvObj);
6511
6512 *ppvObj = NULL;
6513
6514 if(pOuterUnk)
6515 {
6516 WARN("Not able to aggregate\n");
6517 return CLASS_E_NOAGGREGATION;
6518 }
6519
6520 hr = ITypeInfo_GetTypeAttr(iface, &pTA);
6521 if(FAILED(hr)) return hr;
6522
6523 if(pTA->typekind != TKIND_COCLASS)
6524 {
6525 WARN("CreateInstance on typeinfo of type %x\n", pTA->typekind);
6526 hr = E_INVALIDARG;
6527 goto end;
6528 }
6529
6530 hr = S_FALSE;
6531 if(pTA->wTypeFlags & TYPEFLAG_FAPPOBJECT)
6532 {
6533 IUnknown *pUnk;
6534 hr = GetActiveObject(&pTA->guid, NULL, &pUnk);
6535 TRACE("GetActiveObject rets %08x\n", hr);
6536 if(hr == S_OK)
6537 {
6538 hr = IUnknown_QueryInterface(pUnk, riid, ppvObj);
6539 IUnknown_Release(pUnk);
6540 }
6541 }
6542
6543 if(hr != S_OK)
6544 hr = CoCreateInstance(&pTA->guid, NULL,
6545 CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
6546 riid, ppvObj);
6547
6548 end:
6549 ITypeInfo_ReleaseTypeAttr(iface, pTA);
6550 return hr;
6551 }
6552
6553 /* ITypeInfo::GetMops
6554 *
6555 * Retrieves marshalling information.
6556 */
6557 static HRESULT WINAPI ITypeInfo_fnGetMops( ITypeInfo2 *iface, MEMBERID memid,
6558 BSTR *pBstrMops)
6559 {
6560 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6561 FIXME("(%p) stub!\n", This);
6562 return S_OK;
6563 }
6564
6565 /* ITypeInfo::GetContainingTypeLib
6566 *
6567 * Retrieves the containing type library and the index of the type description
6568 * within that type library.
6569 */
6570 static HRESULT WINAPI ITypeInfo_fnGetContainingTypeLib( ITypeInfo2 *iface,
6571 ITypeLib * *ppTLib, UINT *pIndex)
6572 {
6573 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6574
6575 /* If a pointer is null, we simply ignore it, the ATL in particular passes pIndex as 0 */
6576 if (pIndex) {
6577 *pIndex=This->index;
6578 TRACE("returning pIndex=%d\n", *pIndex);
6579 }
6580
6581 if (ppTLib) {
6582 *ppTLib=(LPTYPELIB )(This->pTypeLib);
6583 ITypeLib2_AddRef(*ppTLib);
6584 TRACE("returning ppTLib=%p\n", *ppTLib);
6585 }
6586
6587 return S_OK;
6588 }
6589
6590 /* ITypeInfo::ReleaseTypeAttr
6591 *
6592 * Releases a TYPEATTR previously returned by GetTypeAttr.
6593 *
6594 */
6595 static void WINAPI ITypeInfo_fnReleaseTypeAttr( ITypeInfo2 *iface,
6596 TYPEATTR* pTypeAttr)
6597 {
6598 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6599 TRACE("(%p)->(%p)\n", This, pTypeAttr);
6600 HeapFree(GetProcessHeap(), 0, pTypeAttr);
6601 }
6602
6603 /* ITypeInfo::ReleaseFuncDesc
6604 *
6605 * Releases a FUNCDESC previously returned by GetFuncDesc. *
6606 */
6607 static void WINAPI ITypeInfo_fnReleaseFuncDesc(
6608 ITypeInfo2 *iface,
6609 FUNCDESC *pFuncDesc)
6610 {
6611 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6612 SHORT i;
6613
6614 TRACE("(%p)->(%p)\n", This, pFuncDesc);
6615
6616 for (i = 0; i < pFuncDesc->cParams; i++)
6617 TLB_FreeElemDesc(&pFuncDesc->lprgelemdescParam[i]);
6618 TLB_FreeElemDesc(&pFuncDesc->elemdescFunc);
6619
6620 SysFreeString((BSTR)pFuncDesc);
6621 }
6622
6623 /* ITypeInfo::ReleaseVarDesc
6624 *
6625 * Releases a VARDESC previously returned by GetVarDesc.
6626 */
6627 static void WINAPI ITypeInfo_fnReleaseVarDesc( ITypeInfo2 *iface,
6628 VARDESC *pVarDesc)
6629 {
6630 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6631 TRACE("(%p)->(%p)\n", This, pVarDesc);
6632
6633 TLB_FreeElemDesc(&pVarDesc->elemdescVar);
6634 if (pVarDesc->varkind == VAR_CONST)
6635 VariantClear(pVarDesc->u.lpvarValue);
6636 SysFreeString((BSTR)pVarDesc);
6637 }
6638
6639 /* ITypeInfo2::GetTypeKind
6640 *
6641 * Returns the TYPEKIND enumeration quickly, without doing any allocations.
6642 *
6643 */
6644 static HRESULT WINAPI ITypeInfo2_fnGetTypeKind( ITypeInfo2 * iface,
6645 TYPEKIND *pTypeKind)
6646 {
6647 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6648 *pTypeKind=This->TypeAttr.typekind;
6649 TRACE("(%p) type 0x%0x\n", This,*pTypeKind);
6650 return S_OK;
6651 }
6652
6653 /* ITypeInfo2::GetTypeFlags
6654 *
6655 * Returns the type flags without any allocations. This returns a DWORD type
6656 * flag, which expands the type flags without growing the TYPEATTR (type
6657 * attribute).
6658 *
6659 */
6660 static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags( ITypeInfo2 *iface, ULONG *pTypeFlags)
6661 {
6662 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6663 *pTypeFlags=This->TypeAttr.wTypeFlags;
6664 TRACE("(%p) flags 0x%x\n", This,*pTypeFlags);
6665 return S_OK;
6666 }
6667
6668 /* ITypeInfo2::GetFuncIndexOfMemId
6669 * Binds to a specific member based on a known DISPID, where the member name
6670 * is not known (for example, when binding to a default member).
6671 *
6672 */
6673 static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo2 * iface,
6674 MEMBERID memid, INVOKEKIND invKind, UINT *pFuncIndex)
6675 {
6676 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6677 const TLBFuncDesc *pFuncInfo;
6678 int i;
6679 HRESULT result;
6680
6681 for(i = 0, pFuncInfo = This->funclist; pFuncInfo; i++, pFuncInfo=pFuncInfo->next)
6682 if(memid == pFuncInfo->funcdesc.memid && (invKind & pFuncInfo->funcdesc.invkind))
6683 break;
6684 if(pFuncInfo) {
6685 *pFuncIndex = i;
6686 result = S_OK;
6687 } else
6688 result = TYPE_E_ELEMENTNOTFOUND;
6689
6690 TRACE("(%p) memid 0x%08x invKind 0x%04x -> %s\n", This,
6691 memid, invKind, SUCCEEDED(result) ? "SUCCESS" : "FAILED");
6692 return result;
6693 }
6694
6695 /* TypeInfo2::GetVarIndexOfMemId
6696 *
6697 * Binds to a specific member based on a known DISPID, where the member name
6698 * is not known (for example, when binding to a default member).
6699 *
6700 */
6701 static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo2 * iface,
6702 MEMBERID memid, UINT *pVarIndex)
6703 {
6704 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6705 TLBVarDesc *pVarInfo;
6706 int i;
6707 HRESULT result;
6708 for(i=0, pVarInfo=This->varlist; pVarInfo &&
6709 memid != pVarInfo->vardesc.memid; i++, pVarInfo=pVarInfo->next)
6710 ;
6711 if(pVarInfo) {
6712 *pVarIndex = i;
6713 result = S_OK;
6714 } else
6715 result = TYPE_E_ELEMENTNOTFOUND;
6716
6717 TRACE("(%p) memid 0x%08x -> %s\n", This,
6718 memid, SUCCEEDED(result) ? "SUCCESS" : "FAILED");
6719 return result;
6720 }
6721
6722 /* ITypeInfo2::GetCustData
6723 *
6724 * Gets the custom data
6725 */
6726 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
6727 ITypeInfo2 * iface,
6728 REFGUID guid,
6729 VARIANT *pVarVal)
6730 {
6731 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6732 TLBCustData *pCData;
6733
6734 for(pCData=This->pCustData; pCData; pCData = pCData->next)
6735 if( IsEqualIID(guid, &pCData->guid)) break;
6736
6737 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6738
6739 if(pCData)
6740 {
6741 VariantInit( pVarVal);
6742 VariantCopy( pVarVal, &pCData->data);
6743 return S_OK;
6744 }
6745 return E_INVALIDARG; /* FIXME: correct? */
6746 }
6747
6748 /* ITypeInfo2::GetFuncCustData
6749 *
6750 * Gets the custom data
6751 */
6752 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
6753 ITypeInfo2 * iface,
6754 UINT index,
6755 REFGUID guid,
6756 VARIANT *pVarVal)
6757 {
6758 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6759 TLBCustData *pCData=NULL;
6760 TLBFuncDesc * pFDesc;
6761 int i;
6762 for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
6763 pFDesc=pFDesc->next);
6764
6765 if(pFDesc)
6766 for(pCData=pFDesc->pCustData; pCData; pCData = pCData->next)
6767 if( IsEqualIID(guid, &pCData->guid)) break;
6768
6769 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6770
6771 if(pCData){
6772 VariantInit( pVarVal);
6773 VariantCopy( pVarVal, &pCData->data);
6774 return S_OK;
6775 }
6776 return E_INVALIDARG; /* FIXME: correct? */
6777 }
6778
6779 /* ITypeInfo2::GetParamCustData
6780 *
6781 * Gets the custom data
6782 */
6783 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
6784 ITypeInfo2 * iface,
6785 UINT indexFunc,
6786 UINT indexParam,
6787 REFGUID guid,
6788 VARIANT *pVarVal)
6789 {
6790 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6791 TLBCustData *pCData=NULL;
6792 TLBFuncDesc * pFDesc;
6793 int i;
6794
6795 for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,pFDesc=pFDesc->next);
6796
6797 if(pFDesc && indexParam<pFDesc->funcdesc.cParams)
6798 for(pCData=pFDesc->pParamDesc[indexParam].pCustData; pCData;
6799 pCData = pCData->next)
6800 if( IsEqualIID(guid, &pCData->guid)) break;
6801
6802 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6803
6804 if(pCData)
6805 {
6806 VariantInit( pVarVal);
6807 VariantCopy( pVarVal, &pCData->data);
6808 return S_OK;
6809 }
6810 return E_INVALIDARG; /* FIXME: correct? */
6811 }
6812
6813 /* ITypeInfo2::GetVarCustData
6814 *
6815 * Gets the custom data
6816 */
6817 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
6818 ITypeInfo2 * iface,
6819 UINT index,
6820 REFGUID guid,
6821 VARIANT *pVarVal)
6822 {
6823 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6824 TLBCustData *pCData=NULL;
6825 TLBVarDesc * pVDesc;
6826 int i;
6827
6828 for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next);
6829
6830 if(pVDesc)
6831 {
6832 for(pCData=pVDesc->pCustData; pCData; pCData = pCData->next)
6833 {
6834 if( IsEqualIID(guid, &pCData->guid)) break;
6835 }
6836 }
6837
6838 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6839
6840 if(pCData)
6841 {
6842 VariantInit( pVarVal);
6843 VariantCopy( pVarVal, &pCData->data);
6844 return S_OK;
6845 }
6846 return E_INVALIDARG; /* FIXME: correct? */
6847 }
6848
6849 /* ITypeInfo2::GetImplCustData
6850 *
6851 * Gets the custom data
6852 */
6853 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
6854 ITypeInfo2 * iface,
6855 UINT index,
6856 REFGUID guid,
6857 VARIANT *pVarVal)
6858 {
6859 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6860 TLBCustData *pCData=NULL;
6861 TLBImplType * pRDesc;
6862 int i;
6863
6864 for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++, pRDesc=pRDesc->next);
6865
6866 if(pRDesc)
6867 {
6868 for(pCData=pRDesc->pCustData; pCData; pCData = pCData->next)
6869 {
6870 if( IsEqualIID(guid, &pCData->guid)) break;
6871 }
6872 }
6873
6874 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6875
6876 if(pCData)
6877 {
6878 VariantInit( pVarVal);
6879 VariantCopy( pVarVal, &pCData->data);
6880 return S_OK;
6881 }
6882 return E_INVALIDARG; /* FIXME: correct? */
6883 }
6884
6885 /* ITypeInfo2::GetDocumentation2
6886 *
6887 * Retrieves the documentation string, the complete Help file name and path,
6888 * the localization context to use, and the context ID for the library Help
6889 * topic in the Help file.
6890 *
6891 */
6892 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
6893 ITypeInfo2 * iface,
6894 MEMBERID memid,
6895 LCID lcid,
6896 BSTR *pbstrHelpString,
6897 DWORD *pdwHelpStringContext,
6898 BSTR *pbstrHelpStringDll)
6899 {
6900 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6901 const TLBFuncDesc *pFDesc;
6902 const TLBVarDesc *pVDesc;
6903 TRACE("(%p) memid %d lcid(0x%x) HelpString(%p) "
6904 "HelpStringContext(%p) HelpStringDll(%p)\n",
6905 This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
6906 pbstrHelpStringDll );
6907 /* the help string should be obtained from the helpstringdll,
6908 * using the _DLLGetDocumentation function, based on the supplied
6909 * lcid. Nice to do sometime...
6910 */
6911 if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
6912 if(pbstrHelpString)
6913 *pbstrHelpString=SysAllocString(This->Name);
6914 if(pdwHelpStringContext)
6915 *pdwHelpStringContext=This->dwHelpStringContext;
6916 if(pbstrHelpStringDll)
6917 *pbstrHelpStringDll=
6918 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
6919 return S_OK;
6920 }else {/* for a member */
6921 for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
6922 if(pFDesc->funcdesc.memid==memid){
6923 if(pbstrHelpString)
6924 *pbstrHelpString=SysAllocString(pFDesc->HelpString);
6925 if(pdwHelpStringContext)
6926 *pdwHelpStringContext=pFDesc->HelpStringContext;
6927 if(pbstrHelpStringDll)
6928 *pbstrHelpStringDll=
6929 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
6930 return S_OK;
6931 }
6932 for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
6933 if(pVDesc->vardesc.memid==memid){
6934 if(pbstrHelpString)
6935 *pbstrHelpString=SysAllocString(pVDesc->HelpString);
6936 if(pdwHelpStringContext)
6937 *pdwHelpStringContext=pVDesc->HelpStringContext;
6938 if(pbstrHelpStringDll)
6939 *pbstrHelpStringDll=
6940 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
6941 return S_OK;
6942 }
6943 }
6944 return TYPE_E_ELEMENTNOTFOUND;
6945 }
6946
6947 /* ITypeInfo2::GetAllCustData
6948 *
6949 * Gets all custom data items for the Type info.
6950 *
6951 */
6952 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
6953 ITypeInfo2 * iface,
6954 CUSTDATA *pCustData)
6955 {
6956 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6957 TLBCustData *pCData;
6958 int i;
6959
6960 TRACE("(%p) returning %d items\n", This, This->ctCustData);
6961
6962 pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
6963 if(pCustData->prgCustData ){
6964 pCustData->cCustData=This->ctCustData;
6965 for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
6966 pCustData->prgCustData[i].guid=pCData->guid;
6967 VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
6968 }
6969 }else{
6970 ERR(" OUT OF MEMORY!\n");
6971 return E_OUTOFMEMORY;
6972 }
6973 return S_OK;
6974 }
6975
6976 /* ITypeInfo2::GetAllFuncCustData
6977 *
6978 * Gets all custom data items for the specified Function
6979 *
6980 */
6981 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
6982 ITypeInfo2 * iface,
6983 UINT index,
6984 CUSTDATA *pCustData)
6985 {
6986 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6987 TLBCustData *pCData;
6988 TLBFuncDesc * pFDesc;
6989 int i;
6990 TRACE("(%p) index %d\n", This, index);
6991 for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
6992 pFDesc=pFDesc->next)
6993 ;
6994 if(pFDesc){
6995 pCustData->prgCustData =
6996 TLB_Alloc(pFDesc->ctCustData * sizeof(CUSTDATAITEM));
6997 if(pCustData->prgCustData ){
6998 pCustData->cCustData=pFDesc->ctCustData;
6999 for(i=0, pCData=pFDesc->pCustData; pCData; i++,
7000 pCData = pCData->next){
7001 pCustData->prgCustData[i].guid=pCData->guid;
7002 VariantCopy(& pCustData->prgCustData[i].varValue,
7003 & pCData->data);
7004 }
7005 }else{
7006 ERR(" OUT OF MEMORY!\n");
7007 return E_OUTOFMEMORY;
7008 }
7009 return S_OK;
7010 }
7011 return TYPE_E_ELEMENTNOTFOUND;
7012 }
7013
7014 /* ITypeInfo2::GetAllParamCustData
7015 *
7016 * Gets all custom data items for the Functions
7017 *
7018 */
7019 static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo2 * iface,
7020 UINT indexFunc, UINT indexParam, CUSTDATA *pCustData)
7021 {
7022 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7023 TLBCustData *pCData=NULL;
7024 TLBFuncDesc * pFDesc;
7025 int i;
7026 TRACE("(%p) index %d\n", This, indexFunc);
7027 for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,
7028 pFDesc=pFDesc->next)
7029 ;
7030 if(pFDesc && indexParam<pFDesc->funcdesc.cParams){
7031 pCustData->prgCustData =
7032 TLB_Alloc(pFDesc->pParamDesc[indexParam].ctCustData *
7033 sizeof(CUSTDATAITEM));
7034 if(pCustData->prgCustData ){
7035 pCustData->cCustData=pFDesc->pParamDesc[indexParam].ctCustData;
7036 for(i=0, pCData=pFDesc->pParamDesc[indexParam].pCustData;
7037 pCData; i++, pCData = pCData->next){
7038 pCustData->prgCustData[i].guid=pCData->guid;
7039 VariantCopy(& pCustData->prgCustData[i].varValue,
7040 & pCData->data);
7041 }
7042 }else{
7043 ERR(" OUT OF MEMORY!\n");
7044 return E_OUTOFMEMORY;
7045 }
7046 return S_OK;
7047 }
7048 return TYPE_E_ELEMENTNOTFOUND;
7049 }
7050
7051 /* ITypeInfo2::GetAllVarCustData
7052 *
7053 * Gets all custom data items for the specified Variable
7054 *
7055 */
7056 static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData( ITypeInfo2 * iface,
7057 UINT index, CUSTDATA *pCustData)
7058 {
7059 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7060 TLBCustData *pCData;
7061 TLBVarDesc * pVDesc;
7062 int i;
7063 TRACE("(%p) index %d\n", This, index);
7064 for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++,
7065 pVDesc=pVDesc->next)
7066 ;
7067 if(pVDesc){
7068 pCustData->prgCustData =
7069 TLB_Alloc(pVDesc->ctCustData * sizeof(CUSTDATAITEM));
7070 if(pCustData->prgCustData ){
7071 pCustData->cCustData=pVDesc->ctCustData;
7072 for(i=0, pCData=pVDesc->pCustData; pCData; i++,
7073 pCData = pCData->next){
7074 pCustData->prgCustData[i].guid=pCData->guid;
7075 VariantCopy(& pCustData->prgCustData[i].varValue,
7076 & pCData->data);
7077 }
7078 }else{
7079 ERR(" OUT OF MEMORY!\n");
7080 return E_OUTOFMEMORY;
7081 }
7082 return S_OK;
7083 }
7084 return TYPE_E_ELEMENTNOTFOUND;
7085 }
7086
7087 /* ITypeInfo2::GetAllImplCustData
7088 *
7089 * Gets all custom data items for the specified implementation type
7090 *
7091 */
7092 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
7093 ITypeInfo2 * iface,
7094 UINT index,
7095 CUSTDATA *pCustData)
7096 {
7097 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7098 TLBCustData *pCData;
7099 TLBImplType * pRDesc;
7100 int i;
7101 TRACE("(%p) index %d\n", This, index);
7102 for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++,
7103 pRDesc=pRDesc->next)
7104 ;
7105 if(pRDesc){
7106 pCustData->prgCustData =
7107 TLB_Alloc(pRDesc->ctCustData * sizeof(CUSTDATAITEM));
7108 if(pCustData->prgCustData ){
7109 pCustData->cCustData=pRDesc->ctCustData;
7110 for(i=0, pCData=pRDesc->pCustData; pCData; i++,
7111 pCData = pCData->next){
7112 pCustData->prgCustData[i].guid=pCData->guid;
7113 VariantCopy(& pCustData->prgCustData[i].varValue,
7114 & pCData->data);
7115 }
7116 }else{
7117 ERR(" OUT OF MEMORY!\n");
7118 return E_OUTOFMEMORY;
7119 }
7120 return S_OK;
7121 }
7122 return TYPE_E_ELEMENTNOTFOUND;
7123 }
7124
7125 static const ITypeInfo2Vtbl tinfvt =
7126 {
7127
7128 ITypeInfo_fnQueryInterface,
7129 ITypeInfo_fnAddRef,
7130 ITypeInfo_fnRelease,
7131
7132 ITypeInfo_fnGetTypeAttr,
7133 ITypeInfo_fnGetTypeComp,
7134 ITypeInfo_fnGetFuncDesc,
7135 ITypeInfo_fnGetVarDesc,
7136 ITypeInfo_fnGetNames,
7137 ITypeInfo_fnGetRefTypeOfImplType,
7138 ITypeInfo_fnGetImplTypeFlags,
7139 ITypeInfo_fnGetIDsOfNames,
7140 ITypeInfo_fnInvoke,
7141 ITypeInfo_fnGetDocumentation,
7142 ITypeInfo_fnGetDllEntry,
7143 ITypeInfo_fnGetRefTypeInfo,
7144 ITypeInfo_fnAddressOfMember,
7145 ITypeInfo_fnCreateInstance,
7146 ITypeInfo_fnGetMops,
7147 ITypeInfo_fnGetContainingTypeLib,
7148 ITypeInfo_fnReleaseTypeAttr,
7149 ITypeInfo_fnReleaseFuncDesc,
7150 ITypeInfo_fnReleaseVarDesc,
7151
7152 ITypeInfo2_fnGetTypeKind,
7153 ITypeInfo2_fnGetTypeFlags,
7154 ITypeInfo2_fnGetFuncIndexOfMemId,
7155 ITypeInfo2_fnGetVarIndexOfMemId,
7156 ITypeInfo2_fnGetCustData,
7157 ITypeInfo2_fnGetFuncCustData,
7158 ITypeInfo2_fnGetParamCustData,
7159 ITypeInfo2_fnGetVarCustData,
7160 ITypeInfo2_fnGetImplTypeCustData,
7161 ITypeInfo2_fnGetDocumentation2,
7162 ITypeInfo2_fnGetAllCustData,
7163 ITypeInfo2_fnGetAllFuncCustData,
7164 ITypeInfo2_fnGetAllParamCustData,
7165 ITypeInfo2_fnGetAllVarCustData,
7166 ITypeInfo2_fnGetAllImplTypeCustData,
7167 };
7168
7169 /******************************************************************************
7170 * CreateDispTypeInfo [OLEAUT32.31]
7171 *
7172 * Build type information for an object so it can be called through an
7173 * IDispatch interface.
7174 *
7175 * RETURNS
7176 * Success: S_OK. pptinfo contains the created ITypeInfo object.
7177 * Failure: E_INVALIDARG, if one or more arguments is invalid.
7178 *
7179 * NOTES
7180 * This call allows an objects methods to be accessed through IDispatch, by
7181 * building an ITypeInfo object that IDispatch can use to call through.
7182 */
7183 HRESULT WINAPI CreateDispTypeInfo(
7184 INTERFACEDATA *pidata, /* [I] Description of the interface to build type info for */
7185 LCID lcid, /* [I] Locale Id */
7186 ITypeInfo **pptinfo) /* [O] Destination for created ITypeInfo object */
7187 {
7188 ITypeInfoImpl *pTIClass, *pTIIface;
7189 ITypeLibImpl *pTypeLibImpl;
7190 int param, func;
7191 TLBFuncDesc **ppFuncDesc;
7192 TLBRefType *ref;
7193
7194 TRACE("\n");
7195 pTypeLibImpl = TypeLibImpl_Constructor();
7196 if (!pTypeLibImpl) return E_FAIL;
7197
7198 pTIIface = (ITypeInfoImpl*)ITypeInfo_Constructor();
7199 pTIIface->pTypeLib = pTypeLibImpl;
7200 pTIIface->index = 0;
7201 pTIIface->Name = NULL;
7202 pTIIface->dwHelpContext = -1;
7203 memset(&pTIIface->TypeAttr.guid, 0, sizeof(GUID));
7204 pTIIface->TypeAttr.lcid = lcid;
7205 pTIIface->TypeAttr.typekind = TKIND_INTERFACE;
7206 pTIIface->TypeAttr.wMajorVerNum = 0;
7207 pTIIface->TypeAttr.wMinorVerNum = 0;
7208 pTIIface->TypeAttr.cbAlignment = 2;
7209 pTIIface->TypeAttr.cbSizeInstance = -1;
7210 pTIIface->TypeAttr.cbSizeVft = -1;
7211 pTIIface->TypeAttr.cFuncs = 0;
7212 pTIIface->TypeAttr.cImplTypes = 0;
7213 pTIIface->TypeAttr.cVars = 0;
7214 pTIIface->TypeAttr.wTypeFlags = 0;
7215
7216 ppFuncDesc = &pTIIface->funclist;
7217 for(func = 0; func < pidata->cMembers; func++) {
7218 METHODDATA *md = pidata->pmethdata + func;
7219 *ppFuncDesc = HeapAlloc(GetProcessHeap(), 0, sizeof(**ppFuncDesc));
7220 (*ppFuncDesc)->Name = SysAllocString(md->szName);
7221 (*ppFuncDesc)->funcdesc.memid = md->dispid;
7222 (*ppFuncDesc)->funcdesc.lprgscode = NULL;
7223 (*ppFuncDesc)->funcdesc.funckind = FUNC_VIRTUAL;
7224 (*ppFuncDesc)->funcdesc.invkind = md->wFlags;
7225 (*ppFuncDesc)->funcdesc.callconv = md->cc;
7226 (*ppFuncDesc)->funcdesc.cParams = md->cArgs;
7227 (*ppFuncDesc)->funcdesc.cParamsOpt = 0;
7228 (*ppFuncDesc)->funcdesc.oVft = md->iMeth << 2;
7229 (*ppFuncDesc)->funcdesc.cScodes = 0;
7230 (*ppFuncDesc)->funcdesc.wFuncFlags = 0;
7231 (*ppFuncDesc)->funcdesc.elemdescFunc.tdesc.vt = md->vtReturn;
7232 (*ppFuncDesc)->funcdesc.elemdescFunc.u.paramdesc.wParamFlags = PARAMFLAG_NONE;
7233 (*ppFuncDesc)->funcdesc.elemdescFunc.u.paramdesc.pparamdescex = NULL;
7234 (*ppFuncDesc)->funcdesc.lprgelemdescParam = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
7235 md->cArgs * sizeof(ELEMDESC));
7236 (*ppFuncDesc)->pParamDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
7237 md->cArgs * sizeof(TLBParDesc));
7238 for(param = 0; param < md->cArgs; param++) {
7239 (*ppFuncDesc)->funcdesc.lprgelemdescParam[param].tdesc.vt = md->ppdata[param].vt;
7240 (*ppFuncDesc)->pParamDesc[param].Name = SysAllocString(md->ppdata[param].szName);
7241 }
7242 (*ppFuncDesc)->helpcontext = 0;
7243 (*ppFuncDesc)->HelpStringContext = 0;
7244 (*ppFuncDesc)->HelpString = NULL;
7245 (*ppFuncDesc)->Entry = NULL;
7246 (*ppFuncDesc)->ctCustData = 0;
7247 (*ppFuncDesc)->pCustData = NULL;
7248 (*ppFuncDesc)->next = NULL;
7249 pTIIface->TypeAttr.cFuncs++;
7250 ppFuncDesc = &(*ppFuncDesc)->next;
7251 }
7252
7253 dump_TypeInfo(pTIIface);
7254
7255 pTypeLibImpl->pTypeInfo = pTIIface;
7256 pTypeLibImpl->TypeInfoCount++;
7257
7258 pTIClass = (ITypeInfoImpl*)ITypeInfo_Constructor();
7259 pTIClass->pTypeLib = pTypeLibImpl;
7260 pTIClass->index = 1;
7261 pTIClass->Name = NULL;
7262 pTIClass->dwHelpContext = -1;
7263 memset(&pTIClass->TypeAttr.guid, 0, sizeof(GUID));
7264 pTIClass->TypeAttr.lcid = lcid;
7265 pTIClass->TypeAttr.typekind = TKIND_COCLASS;
7266 pTIClass->TypeAttr.wMajorVerNum = 0;
7267 pTIClass->TypeAttr.wMinorVerNum = 0;
7268 pTIClass->TypeAttr.cbAlignment = 2;
7269 pTIClass->TypeAttr.cbSizeInstance = -1;
7270 pTIClass->TypeAttr.cbSizeVft = -1;
7271 pTIClass->TypeAttr.cFuncs = 0;
7272 pTIClass->TypeAttr.cImplTypes = 1;
7273 pTIClass->TypeAttr.cVars = 0;
7274 pTIClass->TypeAttr.wTypeFlags = 0;
7275
7276 pTIClass->impltypelist = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pTIClass->impltypelist));
7277 pTIClass->impltypelist->hRef = 0;
7278
7279 ref = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ref));
7280 ref->index = 0;
7281 ref->reference = 0;
7282 ref->pImpTLInfo = TLB_REF_INTERNAL;
7283 list_add_head(&pTypeLibImpl->ref_list, &ref->entry);
7284
7285 dump_TypeInfo(pTIClass);
7286
7287 pTIIface->next = pTIClass;
7288 pTypeLibImpl->TypeInfoCount++;
7289
7290 *pptinfo = (ITypeInfo*)pTIClass;
7291
7292 ITypeInfo_AddRef(*pptinfo);
7293 ITypeLib_Release((ITypeLib *)&pTypeLibImpl->lpVtbl);
7294
7295 return S_OK;
7296
7297 }
7298
7299 static HRESULT WINAPI ITypeComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
7300 {
7301 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7302
7303 return ITypeInfo_QueryInterface((ITypeInfo *)This, riid, ppv);
7304 }
7305
7306 static ULONG WINAPI ITypeComp_fnAddRef(ITypeComp * iface)
7307 {
7308 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7309
7310 return ITypeInfo_AddRef((ITypeInfo *)This);
7311 }
7312
7313 static ULONG WINAPI ITypeComp_fnRelease(ITypeComp * iface)
7314 {
7315 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7316
7317 return ITypeInfo_Release((ITypeInfo *)This);
7318 }
7319
7320 static HRESULT WINAPI ITypeComp_fnBind(
7321 ITypeComp * iface,
7322 OLECHAR * szName,
7323 ULONG lHash,
7324 WORD wFlags,
7325 ITypeInfo ** ppTInfo,
7326 DESCKIND * pDescKind,
7327 BINDPTR * pBindPtr)
7328 {
7329 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7330 const TLBFuncDesc *pFDesc;
7331 const TLBVarDesc *pVDesc;
7332 HRESULT hr = DISP_E_MEMBERNOTFOUND;
7333
7334 TRACE("(%s, %x, 0x%x, %p, %p, %p)\n", debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
7335
7336 *pDescKind = DESCKIND_NONE;
7337 pBindPtr->lpfuncdesc = NULL;
7338 *ppTInfo = NULL;
7339
7340 for(pFDesc = This->funclist; pFDesc; pFDesc = pFDesc->next)
7341 if (!strcmpiW(pFDesc->Name, szName)) {
7342 if (!wFlags || (pFDesc->funcdesc.invkind & wFlags))
7343 break;
7344 else
7345 /* name found, but wrong flags */
7346 hr = TYPE_E_TYPEMISMATCH;
7347 }
7348
7349 if (pFDesc)
7350 {
7351 HRESULT hr = TLB_AllocAndInitFuncDesc(
7352 &pFDesc->funcdesc,
7353 &pBindPtr->lpfuncdesc,
7354 This->TypeAttr.typekind == TKIND_DISPATCH);
7355 if (FAILED(hr))
7356 return hr;
7357 *pDescKind = DESCKIND_FUNCDESC;
7358 *ppTInfo = (ITypeInfo *)&This->lpVtbl;
7359 ITypeInfo_AddRef(*ppTInfo);
7360 return S_OK;
7361 } else {
7362 for(pVDesc = This->varlist; pVDesc; pVDesc = pVDesc->next) {
7363 if (!strcmpiW(pVDesc->Name, szName)) {
7364 HRESULT hr = TLB_AllocAndInitVarDesc(&pVDesc->vardesc, &pBindPtr->lpvardesc);
7365 if (FAILED(hr))
7366 return hr;
7367 *pDescKind = DESCKIND_VARDESC;
7368 *ppTInfo = (ITypeInfo *)&This->lpVtbl;
7369 ITypeInfo_AddRef(*ppTInfo);
7370 return S_OK;
7371 }
7372 }
7373 }
7374 /* FIXME: search each inherited interface, not just the first */
7375 if (hr == DISP_E_MEMBERNOTFOUND && This->impltypelist) {
7376 /* recursive search */
7377 ITypeInfo *pTInfo;
7378 ITypeComp *pTComp;
7379 HRESULT hr;
7380 hr=ITypeInfo_GetRefTypeInfo((ITypeInfo *)&This->lpVtbl, This->impltypelist->hRef, &pTInfo);
7381 if (SUCCEEDED(hr))
7382 {
7383 hr = ITypeInfo_GetTypeComp(pTInfo,&pTComp);
7384 ITypeInfo_Release(pTInfo);
7385 }
7386 if (SUCCEEDED(hr))
7387 {
7388 hr = ITypeComp_Bind(pTComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
7389 ITypeComp_Release(pTComp);
7390 return hr;
7391 }
7392 WARN("Could not search inherited interface!\n");
7393 }
7394 WARN("did not find member with name %s, flags 0x%x!\n", debugstr_w(szName), wFlags);
7395 return hr;
7396 }
7397
7398 static HRESULT WINAPI ITypeComp_fnBindType(
7399 ITypeComp * iface,
7400 OLECHAR * szName,
7401 ULONG lHash,
7402 ITypeInfo ** ppTInfo,
7403 ITypeComp ** ppTComp)
7404 {
7405 TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
7406
7407 /* strange behaviour (does nothing) but like the
7408 * original */
7409
7410 if (!ppTInfo || !ppTComp)
7411 return E_POINTER;
7412
7413 *ppTInfo = NULL;
7414 *ppTComp = NULL;
7415
7416 return S_OK;
7417 }
7418
7419 static const ITypeCompVtbl tcompvt =
7420 {
7421
7422 ITypeComp_fnQueryInterface,
7423 ITypeComp_fnAddRef,
7424 ITypeComp_fnRelease,
7425
7426 ITypeComp_fnBind,
7427 ITypeComp_fnBindType
7428 };
Windows API implementation