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