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