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