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