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